nu_plugin_prometheus 0.15.0

A nushell plugin for querying prometheus
use crate::{Prometheus, client::QueryBuilder, source::Source};
use nu_plugin::{EngineInterface, EvaluatedCall, PluginCommand};
use nu_protocol::{
    DynamicSuggestion, LabeledError, PipelineData, PipelineMetadata, Signature, SyntaxShape, Type,
    engine::{ArgType, ExperimentalMarker},
};

#[derive(Clone, Default)]
pub struct QueryRangeCommand;

impl PluginCommand for QueryRangeCommand {
    type Plugin = Prometheus;

    fn name(&self) -> &str {
        "prometheus query range"
    }

    fn signature(&self) -> Signature {
        Signature::build(self.name())
            .description(self.description())
            .named(
                "start",
                SyntaxShape::DateTime,
                "Start timestamp for a range query",
                None,
            )
            .named(
                "end",
                SyntaxShape::DateTime,
                "End timestamp for a range query",
                None,
            )
            .named(
                "step",
                SyntaxShape::Duration,
                "Query resolution step width",
                None,
            )
            .named("timeout", SyntaxShape::Duration, "Evaluation timeout", None)
            .named(
                "source",
                SyntaxShape::String,
                "Prometheus source to query",
                Some('s'),
            )
            .named(
                "url",
                SyntaxShape::String,
                "Prometheus source url to query",
                Some('u'),
            )
            .switch("no-flatten", "Do not flatten labels into record", None)
            .input_output_type(Type::String, Type::Any)
    }

    fn description(&self) -> &str {
        "Run a range query"
    }

    fn get_dynamic_completion(
        &self,
        _plugin: &Self::Plugin,
        engine: &EngineInterface,
        _call: nu_plugin::DynamicCompletionCall,
        arg_type: ArgType,
        _experimental: ExperimentalMarker,
    ) -> Option<Vec<DynamicSuggestion>> {
        let ArgType::Flag(flag) = arg_type else {
            return None;
        };

        match flag.as_ref() {
            "source" => Source::completions(engine),
            _ => None,
        }
    }

    fn run(
        &self,
        _plugin: &Prometheus,
        engine: &EngineInterface,
        call: &EvaluatedCall,
        query: PipelineData,
    ) -> Result<PipelineData, LabeledError> {
        let call_span = call.head;

        let (query, query_span, _) = query.collect_string_strict(call_span)?;

        let source = Source::from(call, engine)?;

        let mut query_builder = QueryBuilder::new(source.try_into()?);

        if let Some(timeout) = call.get_flag("timeout")? {
            query_builder.timeout(timeout);
        }

        if !call.has_flag("no-flatten")? {
            query_builder.flatten();
        }

        let start = call.get_flag("start")?;
        let end = call.get_flag("end")?;
        let step = call.get_flag::<i64>("step")?;

        let (Some(start), Some(end), Some(step)) = (start, end, step) else {
            let mut missing = vec![];

            if call.get_flag_value("start").is_none() {
                missing.push("--start");
            }
            if call.get_flag_value("end").is_none() {
                missing.push("--end");
            }
            if call.get_flag_value("step").is_none() {
                missing.push("--step");
            }
            let missing = missing.join(", ");

            return Err(LabeledError::new("Missing query range arguments")
                .with_label(format!("Missing: {missing}"), call_span));
        };

        let step = step as f64 / 1_000_000_000.0;

        query_builder
            .range(start, end, step, &query, query_span, call_span)
            .run(engine.signals())
            .map(|pipeline| {
                let metadata = PipelineMetadata::default()
                    .with_table_width_priority_columns(call_span, ["name"]);

                pipeline.set_metadata(Some(metadata))
            })
    }
}