Add prometheus metric metadata

Author: drbrain

README.md

@@ -134,6 +134,18 @@ To query "version" label values for the "postgres" job:
 "version" | prometheus label values --url https://prometheus.example:9090/ 'job="postgres"'
 ```
 
+### Metric metadata
+
+Retrieve metric metadata with:
+
+```nushell
+prometheus metric metadata --url https://prometheus.example:9090/
+```
+
+This may take some time, so supply a metric name as input or supply `--limit`
+to reduce the number of records retrieved.  Use `--limit-per-metric` to reduce
+the number of metadata items retrieved per metric.
+
 ## Series
 
 Retrieve series matching the given label set with:

src/client.rs

@@ -2,6 +2,7 @@ mod label_names;
 mod label_names_builder;
 mod label_values;
 mod label_values_builder;
+mod metric_metadata;
 mod query_builder;
 mod query_instant;
 mod query_range;
@@ -13,6 +14,7 @@ pub use label_names::LabelNames;
 pub use label_names_builder::LabelNamesBuilder;
 pub use label_values::LabelValues;
 pub use label_values_builder::LabelValuesBuilder;
+pub use metric_metadata::MetricMetadata;
 use nu_protocol::{LabeledError, Span};
 pub use query_builder::QueryBuilder;
 pub use query_instant::QueryInstant;

src/client/metric_metadata.rs

@@ -0,0 +1,50 @@
+use nu_protocol::{record, LabeledError, Span, Value};
+use prometheus_http_query::MetricMetadataQueryBuilder;
+
+use super::Client;
+
+pub struct MetricMetadata {
+    builder: MetricMetadataQueryBuilder,
+    span: Span,
+}
+
+impl MetricMetadata {
+    pub fn new(builder: MetricMetadataQueryBuilder, span: Span) -> Self {
+        Self { builder, span }
+    }
+
+    pub fn run(self) -> Result<Value, LabeledError> {
+        let Self { ref builder, span } = self;
+
+        self.runtime()?.block_on(async {
+            let metric_metadata = builder
+                .clone()
+                .get()
+                .await
+                .map_err(|error| self.labeled_error(error, span))?;
+
+            let record = metric_metadata
+                .iter()
+                .fold(record!(), |mut record, (metric, metadata)| {
+                    let metadata: Vec<_> =
+                    metadata.iter().map(|item| {
+                        let item = record! {
+                            "type" => Value::string(item.metric_type().to_string(), Span::unknown()),
+                            "help" => Value::string(item.help().to_string(), Span::unknown()),
+                            "unit" => Value::string(item.unit().to_string(), Span::unknown()),
+                        };
+
+                        Value::record(item, Span::unknown())
+                    }).collect();
+
+                    record.insert(metric, Value::list(metadata, Span::unknown()));
+
+                    record
+                });
+
+            Ok(Value::record(record, Span::unknown()))
+        })
+    }
+}
+
+impl Client for MetricMetadata {}

src/main.rs

@@ -7,6 +7,7 @@ use client::Client;
 use nu_plugin::{serve_plugin, JsonSerializer};
 use prometheus::Prometheus;
 use query::Query;
+use source::Source;
 
 fn main() {
     serve_plugin(&Prometheus, JsonSerializer)

src/prometheus.rs

@@ -1,5 +1,6 @@
 mod label_names_command;
 mod label_values_command;
+mod metric_metadata_command;
 mod prometheus_command;
 mod query_command;
 mod query_range_command;
@@ -9,9 +10,10 @@ mod targets_command;
 
 use crate::prometheus::{
     label_names_command::LabelNamesCommand, label_values_command::LabelValuesCommand,
-    prometheus_command::PrometheusCommand, query_command::QueryCommand,
-    query_range_command::QueryRangeCommand, series_command::SeriesCommand,
-    sources_command::SourcesCommand, targets_command::TargetsCommand,
+    metric_metadata_command::MetricMetadataCommand, prometheus_command::PrometheusCommand,
+    query_command::QueryCommand, query_range_command::QueryRangeCommand,
+    series_command::SeriesCommand, sources_command::SourcesCommand,
+    targets_command::TargetsCommand,
 };
 use nu_plugin::Plugin;
 
@@ -23,6 +25,7 @@ impl Plugin for Prometheus {
         vec![
             Box::new(LabelNamesCommand),
             Box::new(LabelValuesCommand),
+            Box::new(MetricMetadataCommand),
             Box::new(PrometheusCommand),
             Box::new(QueryCommand),
             Box::new(QueryRangeCommand),

src/prometheus/metric_metadata_command.rs

@@ -0,0 +1,93 @@
+use crate::{client::MetricMetadata, Prometheus, Source};
+use nu_plugin::{EngineInterface, EvaluatedCall, SimplePluginCommand};
+use nu_protocol::{LabeledError, Signature, SyntaxShape, Type, Value};
+use prometheus_http_query::Client;
+
+#[derive(Clone, Default)]
+pub struct MetricMetadataCommand;
+
+impl SimplePluginCommand for MetricMetadataCommand {
+    type Plugin = Prometheus;
+
+    fn name(&self) -> &str {
+        "prometheus metric metadata"
+    }
+
+    fn signature(&self) -> nu_protocol::Signature {
+        Signature::build(self.name())
+            .usage(self.usage())
+            .named(
+                "source",
+                SyntaxShape::String,
+                "Prometheus source to query",
+                Some('s'),
+            )
+            .named(
+                "url",
+                SyntaxShape::String,
+                "Prometheus source url to query",
+                Some('u'),
+            )
+            .named(
+                "limit",
+                SyntaxShape::Int,
+                "Maximum number of metrics to retrieve",
+                None,
+            )
+            .named(
+                "limit-per-metric",
+                SyntaxShape::Int,
+                "Maximum number of metadata to retrieve per metric",
+                None,
+            )
+            .input_output_types(vec![
+                (Type::Nothing, Type::record()),
+                (Type::String, Type::record()),
+            ])
+    }
+
+    fn usage(&self) -> &str {
+        "Retrieve metric metadata"
+    }
+
+    fn run(
+        &self,
+        _plugin: &Self::Plugin,
+        engine: &EngineInterface,
+        call: &EvaluatedCall,
+        metric: &Value,
+    ) -> Result<Value, LabeledError> {
+        let span = metric.span();
+
+        let client: Client = Source::from(call, engine)?.try_into()?;
+
+        let mut builder = client.metric_metadata();
+
+        if let Value::String { val: metric, .. } = metric {
+            builder = builder.metric(metric);
+        };
+
+        if let Some(limit) = call.get_flag::<i64>("limit")? {
+            let limit = limit.try_into().map_err(|_| {
+                let span = call.get_flag_value("limit").unwrap().span();
+
+                LabeledError::new("Limit too large").with_label("does not fit in i32", span)
+            })?;
+
+            builder = builder.limit(limit);
+        }
+
+        if let Some(limit_per_metric) = call.get_flag::<i64>("limit-per-metric")? {
+            let limit_per_metric = limit_per_metric.try_into().map_err(|_| {
+                let span = call.get_flag_value("limit-per-metric").unwrap().span();
+
+                LabeledError::new("Limit per metric too large")
+                    .with_label("does not fit in i32", span)
+            })?;
+
+            builder = builder.limit_per_metric(limit_per_metric);
+        }
+
+        MetricMetadata::new(builder, span).run()
+    }
+}

src/prometheus/series_command.rs

@@ -1,7 +1,6 @@
 use crate::{
     client::{SelectorParser, Series},
-    source::Source,
-    Prometheus,
+    Prometheus, Source,
 };
 use chrono::{DateTime, FixedOffset};
 use nu_plugin::{EngineInterface, EvaluatedCall, SimplePluginCommand};