hotmic_stdout/

lib.rs

//! Exports metrics by logging them in a textual format.
//!
//! This exporter utilizes the `log` crate to log a textual representation of metrics in a given
//! snapshot.  Metrics that are scoped are represented using an indented tree structure.
//!
//! As an example, for a snapshot with two metrics -- `server.msgs_received` and `server.msgs_sent`
//! -- we would expect to see:
//!
//! ```c
//! root:
//!   server:
//!     msgs_received: 42
//!     msgs_sent: 13
//! ```
//!
//! If we added another metric -- `configuration_reloads` -- we would expect to see:
//!
//! ```c
//! root:
//!   configuration_reloads: 2
//!   server:
//!     msgs_received: 42
//!     msgs_sent: 13
//! ```
//!
//! Metrics are sorted alphabetically.
//!
//! ## Histograms
//!
//! Histograms received a little extra love and care when it comes to formatting.  This is the
//! general format of a given histogram when rendered:
//!
//! ```c
//! root:
//!   connect_time count: 15
//!   connect_time min: 1334ns
//!   connect_time p50: 1934ns
//!   connect_time p99: 5330ns
//!   connect_time max: 139389ns
//! ```
//!
//! The percentiles shown are based on the percentiles configured for hotmic itself, which are
//! generated for us and can't be influenced at the exporter level. The `count` value represents
//! the number of samples in the histogram at the time of measurement.
#[macro_use]
extern crate log;
extern crate hotmic;

use hotmic::{
    snapshot::{Snapshot, SummarizedHistogram, TypedMeasurement},
    Controller,
};
use log::Level;
use std::collections::{HashMap, VecDeque};
use std::fmt::Display;
use std::thread;
use std::time::Duration;

/// Exports metrics by logging them in a textual format.
pub struct StdoutExporter {
    controller: Controller,
    level: Level,
    interval: Duration,
}

impl StdoutExporter {
    /// Creates a new `StdoutExporter`.
    ///
    /// The exporter will take a snapshot based on the configured `controller`, outputting at the
    /// configured `level`, at the configured `interval`.
    pub fn new(controller: Controller, level: Level, interval: Duration) -> Self {
        StdoutExporter {
            controller,
            level,
            interval,
        }
    }

    fn turn(&mut self) {
        match self.controller.get_snapshot() {
            Ok(snapshot) => self.process_snapshot(snapshot),
            Err(e) => error!("caught error getting metrics snapshot: {}", e),
        }
    }

    /// Runs the exporter synchronously, blocking the calling thread.
    ///
    /// You should run this in a dedicated thread:
    ///
    /// ```c
    /// let mut exporter = StdoutExporter::new(controller, Level::Info, Duration::from_secs(5));
    /// std::thread::spawn(move || exporter.run());
    /// ```
    pub fn run(&mut self) {
        loop {
            self.turn();
            thread::sleep(self.interval);
        }
    }

    fn process_snapshot(&self, snapshot: Snapshot) {
        let mut nested = Nested::default();

        for measurement in snapshot.into_vec() {
            let (name_parts, mut values) = match measurement {
                TypedMeasurement::Counter(key, value) => {
                    let (layers, name) = name_to_parts(key);
                    let values = single_value_to_values(name, value);

                    (layers, values)
                }
                TypedMeasurement::Gauge(key, value) => {
                    let (layers, name) = name_to_parts(key);
                    let values = single_value_to_values(name, value);

                    (layers, values)
                }
                TypedMeasurement::TimingHistogram(key, summary) => {
                    let (layers, name) = name_to_parts(key);
                    let values = summary_to_values(name, summary, "ns");

                    (layers, values)
                }
                TypedMeasurement::ValueHistogram(key, summary) => {
                    let (layers, name) = name_to_parts(key);
                    let values = summary_to_values(name, summary, "");

                    (layers, values)
                }
            };

            nested.insert(name_parts, &mut values);
        }

        let output = nested.into_output();
        log!(self.level, "metrics:\n{}", output);
    }
}

fn name_to_parts(name: String) -> (VecDeque<String>, String) {
    let mut parts = name
        .split('.')
        .map(ToOwned::to_owned)
        .collect::<VecDeque<_>>();
    let name = parts.pop_back().expect("name didn't have a single part");

    (parts, name)
}

fn single_value_to_values<T>(name: String, value: T) -> Vec<String>
where
    T: Display,
{
    let fvalue = format!("{}: {}", name, value);
    vec![fvalue]
}

fn summary_to_values(name: String, summary: SummarizedHistogram, suffix: &str) -> Vec<String> {
    let mut values = Vec::new();

    values.push(format!("{} count: {}", name, summary.count()));
    for (percentile, value) in summary.measurements() {
        values.push(format!(
            "{} {}: {}{}",
            name,
            percentile.label(),
            value,
            suffix
        ));
    }

    values
}

struct Nested {
    level: usize,
    current: Vec<String>,
    next: HashMap<String, Nested>,
}

impl Nested {
    pub fn with_level(level: usize) -> Self {
        Nested {
            level,
            ..Default::default()
        }
    }

    pub fn insert(&mut self, mut name_parts: VecDeque<String>, values: &mut Vec<String>) {
        match name_parts.len() {
            0 => {
                let indent = "  ".repeat(self.level + 1);
                let mut indented = values
                    .iter()
                    .map(move |x| format!("{}{}", indent, x))
                    .collect::<Vec<_>>();
                self.current.append(&mut indented);
            }
            _ => {
                let name = name_parts
                    .pop_front()
                    .expect("failed to get next name component");
                let current_level = self.level;
                let inner = self
                    .next
                    .entry(name)
                    .or_insert_with(move || Nested::with_level(current_level + 1));
                inner.insert(name_parts, values);
            }
        }
    }

    pub fn into_output(self) -> String {
        let indent = "  ".repeat(self.level + 1);
        let mut output = String::new();
        if self.level == 0 {
            output.push_str("\nroot:\n");
        }

        let mut sorted = self
            .current
            .into_iter()
            .map(SortEntry::Inline)
            .chain(self.next.into_iter().map(|(k, v)| SortEntry::Nested(k, v)))
            .collect::<Vec<_>>();
        sorted.sort();

        for entry in sorted {
            match entry {
                SortEntry::Inline(s) => {
                    output.push_str(s.as_str());
                    output.push_str("\n");
                }
                SortEntry::Nested(s, inner) => {
                    output.push_str(indent.as_str());
                    output.push_str(s.as_str());
                    output.push_str(":\n");

                    let layer_output = inner.into_output();
                    output.push_str(layer_output.as_str());
                }
            }
        }

        output
    }
}

impl Default for Nested {
    fn default() -> Self {
        Nested {
            level: 0,
            current: Vec::new(),
            next: HashMap::new(),
        }
    }
}

enum SortEntry {
    Inline(String),
    Nested(String, Nested),
}

impl SortEntry {
    fn name(&self) -> &String {
        match self {
            SortEntry::Inline(s) => s,
            SortEntry::Nested(s, _) => s,
        }
    }
}

impl PartialEq for SortEntry {
    fn eq(&self, other: &SortEntry) -> bool {
        self.name() == other.name()
    }
}

impl Eq for SortEntry {}

impl std::cmp::PartialOrd for SortEntry {
    fn partial_cmp(&self, other: &SortEntry) -> Option<std::cmp::Ordering> {
        Some(self.cmp(other))
    }
}

impl std::cmp::Ord for SortEntry {
    fn cmp(&self, other: &SortEntry) -> std::cmp::Ordering {
        self.name().cmp(other.name())
    }
}