feat: record completed calls and active calls

Author: prestwich

src/metrics.rs

@@ -1,7 +1,6 @@
+use metrics::{counter, gauge, Counter, Gauge};
 use std::sync::LazyLock;
 
-use metrics::Counter;
-
 /// Metric name for counting router calls.
 pub(crate) const ROUTER_CALLS: &str = "ajj.router.calls";
 pub(crate) const ROUTER_CALLS_HELP: &str =
@@ -38,6 +37,14 @@ pub(crate) const ROUTER_METHOD_NOT_FOUND: &str = "ajj.router.method_not_found";
 pub(crate) const ROUTER_METHOD_NOT_FOUND_HELP: &str =
     "Number of times ajj router methods encountered a method not found error. This implies a response was sent.";
 
+/// Metric for tracking active calls.
+pub(crate) const ACTIVE_CALLS: &str = "ajj.router.active_calls";
+pub(crate) const ACTIVE_CALLS_HELP: &str = "Number of active calls being processed";
+
+/// Metric for tracking completed   calls.
+pub(crate) const COMPLETED_CALLS: &str = "ajj.router.completed_calls";
+pub(crate) const COMPLETED_CALLS_HELP: &str = "Number of completed calls handled";
+
 static DESCRIBE: LazyLock<()> = LazyLock::new(|| {
     metrics::describe_counter!(ROUTER_CALLS, metrics::Unit::Count, ROUTER_CALLS_HELP);
     metrics::describe_counter!(ROUTER_ERRORS, metrics::Unit::Count, ROUTER_ERRORS_HELP);
@@ -66,12 +73,14 @@ static DESCRIBE: LazyLock<()> = LazyLock::new(|| {
         metrics::Unit::Count,
         ROUTER_METHOD_NOT_FOUND_HELP
     );
+    metrics::describe_gauge!(ACTIVE_CALLS, metrics::Unit::Count, ACTIVE_CALLS_HELP);
+    metrics::describe_counter!(COMPLETED_CALLS, metrics::Unit::Count, COMPLETED_CALLS_HELP);
 });
 
 /// Get or register a counter for calls to a specific service and method.
 pub(crate) fn calls(service_name: &'static str, method: &str) -> Counter {
     let _ = &DESCRIBE;
-    metrics::counter!(
+    counter!(
         ROUTER_CALLS,
         "service" => service_name.to_string(),
         "method" => method.to_string()
@@ -82,12 +91,13 @@ pub(crate) fn calls(service_name: &'static str, method: &str) -> Counter {
 pub(crate) fn record_call(service_name: &'static str, method: &str) {
     let counter = calls(service_name, method);
     counter.increment(1);
+    increment_active_calls(service_name, method);
 }
 
 /// Get or register a counter for errors from a specific service and method.
 pub(crate) fn errors(service_name: &'static str, method: &str) -> Counter {
     let _ = &DESCRIBE;
-    metrics::counter!(
+    counter!(
         ROUTER_ERRORS,
         "service" => service_name.to_string(),
         "method" => method.to_string()
@@ -103,7 +113,7 @@ pub(crate) fn record_execution_error(service_name: &'static str, method: &str) {
 /// Get or register a counter for successes from a specific service and method.
 pub(crate) fn successes(service_name: &'static str, method: &str) -> Counter {
     let _ = &DESCRIBE;
-    metrics::counter!(
+    counter!(
         ROUTER_SUCCESSES,
         "service" => service_name.to_string(),
         "method" => method.to_string()
@@ -129,7 +139,7 @@ pub(crate) fn record_execution(success: bool, service_name: &'static str, method
 /// Get or register a counter for responses from a specific service and method.
 pub(crate) fn responses(service_name: &'static str, method: &str) -> Counter {
     let _ = &DESCRIBE;
-    metrics::counter!(
+    counter!(
         ROUTER_RESPONSES,
         "service" => service_name.to_string(),
         "method" => method.to_string()
@@ -145,7 +155,7 @@ pub(crate) fn record_response(service_name: &'static str, method: &str) {
 /// Get or register a counter for omitted notification responses from a specific service and method.
 pub(crate) fn response_omitted(service_name: &'static str, method: &str) -> Counter {
     let _ = &DESCRIBE;
-    metrics::counter!(
+    counter!(
         ROUTER_NOTIFICATION_RESPONSE_OMITTED,
         "service" => service_name.to_string(),
         "method" => method.to_string()
@@ -165,12 +175,14 @@ pub(crate) fn record_output(response_sent: bool, service_name: &'static str, met
     } else {
         record_response_omitted(service_name, method);
     }
+    record_completed_call(service_name, method);
+    decrement_active_calls(service_name, method);
 }
 
 // Get or register a counter for parse errors.
 pub(crate) fn parse_errors(service_name: &'static str) -> Counter {
     let _ = &DESCRIBE;
-    metrics::counter!(ROUTER_PARSE_ERRORS, "service" => service_name.to_string())
+    counter!(ROUTER_PARSE_ERRORS, "service" => service_name.to_string())
 }
 
 /// Record a parse error.
@@ -182,7 +194,7 @@ pub(crate) fn record_parse_error(service_name: &'static str) {
 /// Get or register a counter for method not found errors.
 pub(crate) fn method_not_found_errors(service_name: &'static str, method: &str) -> Counter {
     let _ = &DESCRIBE;
-    metrics::counter!(ROUTER_METHOD_NOT_FOUND, "service" => service_name.to_string(), "method" => method.to_string())
+    counter!(ROUTER_METHOD_NOT_FOUND, "service" => service_name.to_string(), "method" => method.to_string())
 }
 
 /// Record a method not found error.
@@ -195,3 +207,40 @@ pub(crate) fn record_method_not_found(
     counter.increment(1);
     record_output(response_sent, service_name, method);
 }
+
+/// Get or register a gauge for active calls to a specific service.
+pub(crate) fn active_calls(service_name: &'static str, method: &str) -> Gauge {
+    let _ = &DESCRIBE;
+    gauge!(ACTIVE_CALLS, "service" => service_name.to_string(), "method" => method.to_string())
+}
+
+/// Increment the active calls gauge for a specific service.
+pub(crate) fn increment_active_calls(service_name: &'static str, method: &str) {
+    let _ = &DESCRIBE;
+    let gauge = active_calls(service_name, method);
+    gauge.increment(1);
+}
+
+/// Decrement the active calls gauge for a specific service.
+pub(crate) fn decrement_active_calls(service_name: &'static str, method: &str) {
+    let _ = &DESCRIBE;
+    let gauge = active_calls(service_name, method);
+    gauge.decrement(1);
+}
+
+/// Get or register a counter for completed calls to a specific service.
+pub(crate) fn completed_calls(service_name: &'static str, method: &str) -> Counter {
+    let _ = &DESCRIBE;
+    counter!(
+        COMPLETED_CALLS,
+        "service" => service_name.to_string(),
+        "method" => method.to_string()
+    )
+}
+
+/// Record a completed call to a specific service and method.
+pub(crate) fn record_completed_call(service_name: &'static str, method: &str) {
+    let _ = &DESCRIBE;
+    let counter = completed_calls(service_name, method);
+    counter.increment(1);
+}

src/router.rs

@@ -111,6 +111,19 @@ where
         self.inner.service_name()
     }
 
+    /// Set the OpenTelemetry service name for this router, overriding any
+    /// existing name.
+    ///
+    /// ## Note
+    ///
+    /// Routers wrap an `Arc`. If multiple references to the router exist,
+    /// this method will clone the inner state before setting the name.
+    pub fn set_name(self, service_name: &'static str) -> Self {
+        tap_inner!(self, mut this => {
+            this.service_name = Some(service_name);
+        })
+    }
+
     /// If this router is the only reference to its inner state, return the
     /// inner state. Otherwise, clone the inner state and return the clone.
     fn into_inner(self) -> RouterInner<S> {