temporalio 0.1.0 → 0.2.0

data/bridge/sdk-core/client/src/metrics.rs

@@ -1,174 +0,0 @@
-use crate::{AttachMetricLabels, LONG_POLL_METHOD_NAMES};
-use futures::{future::BoxFuture, FutureExt};
-use opentelemetry::{
-    metrics::{Counter, Histogram},
-    KeyValue,
-};
-use std::{
-    sync::Arc,
-    task::{Context, Poll},
-    time::{Duration, Instant},
-};
-use tonic::{body::BoxBody, transport::Channel};
-use tower::Service;
-
-/// Used to track context associated with metrics, and record/update them
-// Possible improvement: make generic over some type tag so that methods are only exposed if the
-// appropriate k/vs have already been set.
-#[derive(Clone, Debug)]
-pub struct MetricsContext {
-    ctx: opentelemetry::Context,
-    kvs: Arc<Vec<KeyValue>>,
-    poll_is_long: bool,
-
-    svc_request: Counter<u64>,
-    svc_request_failed: Counter<u64>,
-    long_svc_request: Counter<u64>,
-    long_svc_request_failed: Counter<u64>,
-
-    svc_request_latency: Histogram<u64>,
-    long_svc_request_latency: Histogram<u64>,
-}
-
-/// Things that can provide metrics for the client implement this. Trait exists to avoid having
-/// to make a whole new lower-level crate just for a tiny shared wrapper around OTel meters.
-pub trait ClientMetricProvider {
-    /// Construct a counter metric
-    fn counter(&self, name: &'static str) -> Counter<u64>;
-    /// Construct a histogram metric
-    fn histogram(&self, name: &'static str) -> Histogram<u64>;
-}
-
-impl MetricsContext {
-    pub(crate) fn new(kvs: Vec<KeyValue>, metric_provider: &dyn ClientMetricProvider) -> Self {
-        Self {
-            ctx: opentelemetry::Context::current(),
-            kvs: Arc::new(kvs),
-            poll_is_long: false,
-            svc_request: metric_provider.counter("request"),
-            svc_request_failed: metric_provider.counter("request_failure"),
-            long_svc_request: metric_provider.counter("long_request"),
-            long_svc_request_failed: metric_provider.counter("long_request_failure"),
-            svc_request_latency: metric_provider.histogram("request_latency"),
-            long_svc_request_latency: metric_provider.histogram("long_request_latency"),
-        }
-    }
-
-    /// Extend an existing metrics context with new attributes, returning a new one
-    pub(crate) fn with_new_attrs(&self, new_kvs: impl IntoIterator<Item = KeyValue>) -> Self {
-        let mut r = self.clone();
-        r.add_new_attrs(new_kvs);
-        r
-    }
-
-    /// Add new attributes to the context, mutating it
-    pub(crate) fn add_new_attrs(&mut self, new_kvs: impl IntoIterator<Item = KeyValue>) {
-        Arc::make_mut(&mut self.kvs).extend(new_kvs);
-    }
-
-    pub(crate) fn set_is_long_poll(&mut self) {
-        self.poll_is_long = true;
-    }
-
-    /// A request to the temporal service was made
-    pub(crate) fn svc_request(&self) {
-        if self.poll_is_long {
-            self.long_svc_request.add(&self.ctx, 1, &self.kvs);
-        } else {
-            self.svc_request.add(&self.ctx, 1, &self.kvs);
-        }
-    }
-
-    /// A request to the temporal service failed
-    pub(crate) fn svc_request_failed(&self) {
-        if self.poll_is_long {
-            self.long_svc_request_failed.add(&self.ctx, 1, &self.kvs);
-        } else {
-            self.svc_request_failed.add(&self.ctx, 1, &self.kvs);
-        }
-    }
-
-    /// Record service request latency
-    pub(crate) fn record_svc_req_latency(&self, dur: Duration) {
-        if self.poll_is_long {
-            self.long_svc_request_latency
-                .record(&self.ctx, dur.as_millis() as u64, &self.kvs);
-        } else {
-            self.svc_request_latency
-                .record(&self.ctx, dur.as_millis() as u64, &self.kvs);
-        }
-    }
-}
-
-const KEY_NAMESPACE: &str = "namespace";
-const KEY_SVC_METHOD: &str = "operation";
-const KEY_TASK_QUEUE: &str = "task_queue";
-
-pub(crate) fn namespace_kv(ns: String) -> KeyValue {
-    KeyValue::new(KEY_NAMESPACE, ns)
-}
-
-pub(crate) fn task_queue_kv(tq: String) -> KeyValue {
-    KeyValue::new(KEY_TASK_QUEUE, tq)
-}
-
-pub(crate) fn svc_operation(op: String) -> KeyValue {
-    KeyValue::new(KEY_SVC_METHOD, op)
-}
-
-/// Implements metrics functionality for gRPC (really, any http) calls
-#[derive(Debug, Clone)]
-pub struct GrpcMetricSvc {
-    pub(crate) inner: Channel,
-    // If set to none, metrics are a no-op
-    pub(crate) metrics: Option<MetricsContext>,
-}
-
-impl Service<http::Request<BoxBody>> for GrpcMetricSvc {
-    type Response = http::Response<tonic::transport::Body>;
-    type Error = tonic::transport::Error;
-    type Future = BoxFuture<'static, Result<Self::Response, Self::Error>>;
-
-    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        self.inner.poll_ready(cx).map_err(Into::into)
-    }
-
-    fn call(&mut self, mut req: http::Request<BoxBody>) -> Self::Future {
-        let metrics = self
-            .metrics
-            .clone()
-            .map(|m| {
-                // Attach labels from client wrapper
-                if let Some(other_labels) = req.extensions_mut().remove::<AttachMetricLabels>() {
-                    m.with_new_attrs(other_labels.labels)
-                } else {
-                    m
-                }
-            })
-            .and_then(|mut metrics| {
-                // Attach method name label if possible
-                req.uri().to_string().rsplit_once('/').map(|split_tup| {
-                    let method_name = split_tup.1;
-                    metrics.add_new_attrs([svc_operation(method_name.to_string())]);
-                    if LONG_POLL_METHOD_NAMES.contains(&method_name) {
-                        metrics.set_is_long_poll();
-                    }
-                    metrics.svc_request();
-                    metrics
-                })
-            });
-        let callfut = self.inner.call(req);
-        async move {
-            let started = Instant::now();
-            let res = callfut.await;
-            if let Some(metrics) = metrics {
-                metrics.record_svc_req_latency(started.elapsed());
-                if res.is_err() {
-                    metrics.svc_request_failed();
-                }
-            }
-            res
-        }
-        .boxed()
-    }
-}