Add function name to metrics

Signed-off-by: Ludvig Liljenberg <[email protected]>

Author: ludfjig

docs/hyperlight-metrics-logs-and-traces.md

@@ -11,22 +11,21 @@ Hyperlight provides the following observability features:
 Metrics are provided using the [metrics](https://docs.rs/metrics/latest/metrics/index.html) crate, which is a lightweight metrics facade. When an executable installs a recorder, Hyperlight will emit its metrics to that record, which allows library authors to seamless emit their own metrics without knowing or caring which exporter implementation is chosen, or even if one is installed. In case no recorder is installed, the metrics will be emitted to the default recorder, which is a no-op implementation with minimal overhead.
 
 There are many different implementations of recorders. One example is the [prometheus exporter](https://docs.rs/metrics-exporter-prometheus/latest/metrics_exporter_prometheus/) which can be used to export metrics to a Prometheus server. 
-Hyperlight provides metrics using Prometheus.
 
 The following metrics are provided and are enabled by default:
 
-* `NUM_GUEST_ERRORS` - Counter that tracks the number of guest errors by code and message.
-* `NUM_GUEST_CANCELLATIONS` - Counter that tracks the number of guest executions that have been cancelled because the execution time exceeded the time allowed.
+* `guest_errors_total` - Counter that tracks the number of guest errors by error code.
+* `guest_cancellations_total` - Counter that tracks the number of guest executions that have been cancelled because the execution time exceeded the time allowed.
 
-The following metrics are provided but are disabled by default and require the feature `function_call_metrics` to be enabled:
+The following metrics are provided but are disabled by default:
 
-* `GUEST_CALL_DURATION` - Histogram that tracks the execution time of guest functions in seconds by function name. The histogram also tracks the number of calls to each function.
-* `HOST_CALL_DURATION` - Histogram that tracks the execution time of host functions in seconds by function name. The histogram also tracks the number of calls to each function.
+* `guest_call_duration_seconds` - Histogram that tracks the execution time of guest functions in seconds by function name. The histogram also tracks the number of calls to each function.
+* `host_call_duration_seconds` - Histogram that tracks the execution time of host functions in seconds by function name. The histogram also tracks the number of calls to each function.
 
 The rationale for disabling the function call metrics by default is that:
-
 * A Hyperlight host may wish to provide its own metrics for function calls.
 * Enabling a trace subscriber will cause the function call metrics to be emitted as trace events, which may be sufficient for some use cases.
+* These 2 metrics require string clones for the function names, which may be too expensive for some use cases.
 
 There is an example of how to gather metrics in the [examples/metrics](../src/hyperlight_host/examples/metrics) directory.
 ## Logs

src/hyperlight_host/src/func/guest_err.rs

@@ -29,7 +29,7 @@ pub(crate) fn check_for_guest_error(mgr: &MemMgrWrapper<HostSharedMemory>) -> Re
         ErrorCode::NoError => Ok(()),
         ErrorCode::OutbError => match mgr.as_ref().get_host_error()? {
             Some(host_err) => {
-                CounterMetric::guest_error(guest_err.code.into(), guest_err.message.clone()).emit();
+                CounterMetric::guest_error(guest_err.code.into()).emit();
 
                 log_then_return!(OutBHandlingError(
                     host_err.source.clone(),
@@ -40,11 +40,11 @@ pub(crate) fn check_for_guest_error(mgr: &MemMgrWrapper<HostSharedMemory>) -> Re
             None => Ok(()),
         },
         ErrorCode::StackOverflow => {
-            CounterMetric::guest_error(guest_err.code.into(), guest_err.message.clone()).emit();
+            CounterMetric::guest_error(guest_err.code.into()).emit();
             log_then_return!(StackOverflow());
         }
         _ => {
-            CounterMetric::guest_error(guest_err.code.into(), guest_err.message.clone()).emit();
+            CounterMetric::guest_error(guest_err.code.into()).emit();
             log_then_return!(GuestError(guest_err.code, guest_err.message.clone()));
         }
     }

src/hyperlight_host/src/hypervisor/hypervisor_handler.rs

@@ -48,7 +48,7 @@ use crate::mem::mgr::SandboxMemoryManager;
 use crate::mem::ptr::{GuestPtr, RawPtr};
 use crate::mem::ptr_offset::Offset;
 use crate::mem::shared_mem::{GuestSharedMemory, HostSharedMemory, SharedMemory};
-use crate::metrics::Metric;
+use crate::metrics::HistogramMetric;
 #[cfg(gdb)]
 use crate::sandbox::config::DebugInfo;
 use crate::sandbox::hypervisor::{get_available_hypervisor, HypervisorType};
@@ -432,37 +432,22 @@ impl HypervisorHandler {
                                     })?
                                     .shared_mem
                                     .lock
-                                    .try_read();
-
-                                let res = {
-                                    #[cfg(feature = "function_call_metrics")]
-                                    {
-                                        use crate::metrics::HistogramMetric;
+                                        .try_read();
 
-                                        let start = std::time::Instant::now();
-                                        let result = hv.dispatch_call_from_host(
+                                let res = HistogramMetric::time_and_emit_guest_call(
+                                    function_name.clone(),
+                                    || {
+                                        hv.dispatch_call_from_host(
                                             dispatch_function_addr,
                                             configuration.outb_handler.clone(),
                                             configuration.mem_access_handler.clone(),
                                             Some(hv_handler_clone.clone()),
                                             #[cfg(gdb)]
                                             configuration.dbg_mem_access_handler.clone(),
-                                        );
-                                        let elapsed = start.elapsed();
-                                        HistogramMetric::guest_call(elapsed).emit();
-                                        result
-                                    }
+                                        )
+                                    },
+                                );
 
-                                    #[cfg(not(feature = "function_call_metrics"))]
-                                    hv.dispatch_call_from_host(
-                                        dispatch_function_addr,
-                                        configuration.outb_handler.clone(),
-                                        configuration.mem_access_handler.clone(),
-                                        Some(hv_handler_clone.clone()),
-                                        #[cfg(gdb)]
-                                        configuration.dbg_mem_access_handler.clone(),
-                                    )
-                                };
                                 drop(mem_lock_guard);
                                 drop(evar_lock_guard);
 

src/hyperlight_host/src/metrics/int_gauge_vec.rs

@@ -7,28 +7,28 @@ pub(crate) trait NamedMetric {
 #[macro_export]
 macro_rules! define_metrics {
     (
-        $( $metric_type:ident {
+        $( $metric_type:ident $( < $( $gen:tt ),+ > )? {
             $(
                 $( #[cfg($feature:meta)] )?
-                $variant:ident $( { $($field_name:ident : $field_ty:ty),* } )? => $name:expr
+                $variant:ident $( { $($field_name:ident : $field_ty:ty),* $(,)? } )? => $name:expr
             ),* $(,)?
         } )*
     ) => {
         $(
             #[derive(Debug, Clone)]
-            pub(crate) enum $metric_type {
+            pub(crate) enum $metric_type $( < $( $gen ),+ > )? {
                 $(
                     $( #[cfg($feature)] )?
                     $variant $( { $($field_name : $field_ty),* } )?
                 ),*
             }
 
-            impl $crate::metrics::metrics_macro::NamedMetric for $metric_type {
+            impl $( < $( $gen ),+ > )? $crate::metrics::metrics_macro::NamedMetric for $metric_type $( < $( $gen ),+ > )? {
                 fn name(&self) -> &'static str {
                     match self {
                         $(
                             $( #[cfg($feature)] )?
-                            Self::$variant{..} => $name,
+                            Self::$variant { .. } => $name,
                         )*
                     }
                 }