diff options
Diffstat (limited to 'runtime/metrics.rs')
| -rw-r--r-- | runtime/metrics.rs | 210 |
1 files changed, 0 insertions, 210 deletions
diff --git a/runtime/metrics.rs b/runtime/metrics.rs deleted file mode 100644 index bdcf2b84e..000000000 --- a/runtime/metrics.rs +++ /dev/null @@ -1,210 +0,0 @@ -// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license. -use crate::ops::UnstableChecker; -use deno_core::error::AnyError; -use deno_core::op_sync; -use deno_core::serde::Serialize; -use deno_core::serde_json::json; -use deno_core::serde_json::Value; -use deno_core::Extension; -use deno_core::OpState; - -pub fn init() -> Extension { - Extension::builder() - .ops(vec![("op_metrics", op_sync(op_metrics))]) - .state(|state| { - state.put(RuntimeMetrics::default()); - Ok(()) - }) - .middleware(metrics_op) - .build() -} - -#[derive(serde::Serialize)] -struct MetricsReturn { - combined: OpMetrics, - ops: Value, -} - -fn op_metrics( - state: &mut OpState, - _: (), - _: (), -) -> Result<MetricsReturn, AnyError> { - let m = state.borrow::<RuntimeMetrics>(); - let combined = m.combined_metrics(); - let unstable_checker = state.borrow::<UnstableChecker>(); - let maybe_ops = if unstable_checker.unstable { - Some(&m.ops) - } else { - None - }; - Ok(MetricsReturn { - combined, - ops: json!(maybe_ops), - }) -} -#[derive(Default, Debug)] -pub struct RuntimeMetrics { - pub ops: HashMap<&'static str, OpMetrics>, -} - -impl RuntimeMetrics { - pub fn combined_metrics(&self) -> OpMetrics { - let mut total = OpMetrics::default(); - - for metrics in self.ops.values() { - total.ops_dispatched += metrics.ops_dispatched; - total.ops_dispatched_sync += metrics.ops_dispatched_sync; - total.ops_dispatched_async += metrics.ops_dispatched_async; - total.ops_dispatched_async_unref += metrics.ops_dispatched_async_unref; - total.ops_completed += metrics.ops_completed; - total.ops_completed_sync += metrics.ops_completed_sync; - total.ops_completed_async += metrics.ops_completed_async; - total.ops_completed_async_unref += metrics.ops_completed_async_unref; - total.bytes_sent_control += metrics.bytes_sent_control; - total.bytes_sent_data += metrics.bytes_sent_data; - total.bytes_received += metrics.bytes_received; - } - - total - } -} - -#[derive(Default, Debug, Serialize)] -#[serde(rename_all = "camelCase")] -pub struct OpMetrics { - pub ops_dispatched: u64, - pub ops_dispatched_sync: u64, - pub ops_dispatched_async: u64, - pub ops_dispatched_async_unref: u64, - pub ops_completed: u64, - pub ops_completed_sync: u64, - pub ops_completed_async: u64, - pub ops_completed_async_unref: u64, - pub bytes_sent_control: u64, - pub bytes_sent_data: u64, - pub bytes_received: u64, -} - -impl OpMetrics { - fn op_dispatched( - &mut self, - bytes_sent_control: usize, - bytes_sent_data: usize, - ) { - self.ops_dispatched += 1; - self.bytes_sent_control += bytes_sent_control as u64; - self.bytes_sent_data += bytes_sent_data as u64; - } - - fn op_completed(&mut self, bytes_received: usize) { - self.ops_completed += 1; - self.bytes_received += bytes_received as u64; - } - - pub fn op_sync( - &mut self, - bytes_sent_control: usize, - bytes_sent_data: usize, - bytes_received: usize, - ) { - self.ops_dispatched_sync += 1; - self.op_dispatched(bytes_sent_control, bytes_sent_data); - self.ops_completed_sync += 1; - self.op_completed(bytes_received); - } - - pub fn op_dispatched_async( - &mut self, - bytes_sent_control: usize, - bytes_sent_data: usize, - ) { - self.ops_dispatched_async += 1; - self.op_dispatched(bytes_sent_control, bytes_sent_data) - } - - pub fn op_dispatched_async_unref( - &mut self, - bytes_sent_control: usize, - bytes_sent_data: usize, - ) { - self.ops_dispatched_async_unref += 1; - self.op_dispatched(bytes_sent_control, bytes_sent_data) - } - - pub fn op_completed_async(&mut self, bytes_received: usize) { - self.ops_completed_async += 1; - self.op_completed(bytes_received); - } - - pub fn op_completed_async_unref(&mut self, bytes_received: usize) { - self.ops_completed_async_unref += 1; - self.op_completed(bytes_received); - } -} - -use deno_core::Op; -use deno_core::OpFn; -use std::collections::HashMap; - -pub fn metrics_op(name: &'static str, op_fn: Box<OpFn>) -> Box<OpFn> { - Box::new(move |op_state, payload| -> Op { - // TODOs: - // * The 'bytes' metrics seem pretty useless, especially now that the - // distinction between 'control' and 'data' buffers has become blurry. - // * Tracking completion of async ops currently makes us put the boxed - // future into _another_ box. Keeping some counters may not be expensive - // in itself, but adding a heap allocation for every metric seems bad. - - // TODO: remove this, doesn't make a ton of sense - let bytes_sent_control = 0; - let bytes_sent_data = 0; - - let op = (op_fn)(op_state.clone(), payload); - - let op_state_ = op_state.clone(); - let mut s = op_state.borrow_mut(); - let runtime_metrics = s.borrow_mut::<RuntimeMetrics>(); - - let metrics = if let Some(metrics) = runtime_metrics.ops.get_mut(name) { - metrics - } else { - runtime_metrics.ops.insert(name, OpMetrics::default()); - runtime_metrics.ops.get_mut(name).unwrap() - }; - - use deno_core::futures::future::FutureExt; - - match op { - Op::Sync(result) => { - metrics.op_sync(bytes_sent_control, bytes_sent_data, 0); - Op::Sync(result) - } - Op::Async(fut) => { - metrics.op_dispatched_async(bytes_sent_control, bytes_sent_data); - let fut = fut - .inspect(move |_resp| { - let mut s = op_state_.borrow_mut(); - let runtime_metrics = s.borrow_mut::<RuntimeMetrics>(); - let metrics = runtime_metrics.ops.get_mut(name).unwrap(); - metrics.op_completed_async(0); - }) - .boxed_local(); - Op::Async(fut) - } - Op::AsyncUnref(fut) => { - metrics.op_dispatched_async_unref(bytes_sent_control, bytes_sent_data); - let fut = fut - .inspect(move |_resp| { - let mut s = op_state_.borrow_mut(); - let runtime_metrics = s.borrow_mut::<RuntimeMetrics>(); - let metrics = runtime_metrics.ops.get_mut(name).unwrap(); - metrics.op_completed_async_unref(0); - }) - .boxed_local(); - Op::AsyncUnref(fut) - } - other => other, - } - }) -} |