use crate::ast::{
FilterOp, FilterValue, Grouping, LabelExtraction, LabelFilterExpr, LabelFilterPred,
LabelFormat, LabelFormatValue, LabelMatcher, LabelPredicate, LineFilter, LineFilterOp,
LogQuery, LogfmtStage, MatchOp, PipelineStage, StreamSelector, Unwrap,
};
use crate::lexer::{LexError, tokenize};
use crate::metric::{
AggregationFunction, BinOp, BinaryExpr, MetricQuery, RangeAggregation, RangeFunction,
VectorAggregation, VectorMatch,
};
use crate::token::{SpannedToken, Token};
#[derive(Debug, Clone, PartialEq)]
#[non_exhaustive]
pub enum Expr {
Log(LogQuery),
Metric(MetricQuery),
}
#[derive(Debug, Clone, PartialEq, thiserror::Error)]
#[error("{message} at line {line}, column {col}")]
#[non_exhaustive]
pub struct ParseError {
pub message: String,
pub line: u32,
pub col: u32,
}
impl From<LexError> for ParseError {
fn from(e: LexError) -> Self {
Self {
message: e.message,
line: e.line,
col: e.col,
}
}
}
pub fn parse_query(input: &str) -> Result<LogQuery, ParseError> {
let mut parser = Parser::new(input)?;
let selector = parser.parse_selector()?;
let pipeline = parser.parse_pipeline()?;
parser.expect_eof()?;
Ok(LogQuery { selector, pipeline })
}
pub fn parse_selector(input: &str) -> Result<StreamSelector, ParseError> {
let mut parser = Parser::new(input)?;
let selector = parser.parse_selector()?;
parser.expect_eof()?;
Ok(selector)
}
pub fn parse(input: &str) -> Result<Expr, ParseError> {
let mut parser = Parser::new(input)?;
let expr = if matches!(parser.peek().map(|t| &t.token), Some(Token::LBrace)) {
let selector = parser.parse_selector()?;
let pipeline = parser.parse_pipeline()?;
Expr::Log(LogQuery { selector, pipeline })
} else {
Expr::Metric(parser.parse_metric_expr()?)
};
parser.expect_eof()?;
Ok(expr)
}
pub fn parse_metric_query(input: &str) -> Result<MetricQuery, ParseError> {
let mut parser = Parser::new(input)?;
let query = parser.parse_metric_expr()?;
parser.expect_eof()?;
Ok(query)
}
pub(crate) struct Parser {
tokens: Vec<SpannedToken>,
pos: usize,
end: (u32, u32),
}
impl Parser {
pub(crate) fn new(input: &str) -> Result<Self, ParseError> {
let tokens = tokenize(input)?;
let end = tokens
.last()
.map(|t| (t.line, t.col + t.token.to_string().len() as u32))
.unwrap_or((1, 1));
Ok(Self {
tokens,
pos: 0,
end,
})
}
fn peek(&self) -> Option<&SpannedToken> {
self.tokens.get(self.pos)
}
fn next(&mut self) -> Option<SpannedToken> {
let t = self.tokens.get(self.pos).cloned();
if t.is_some() {
self.pos += 1;
}
t
}
fn error_at(&self, message: impl Into<String>, at: Option<&SpannedToken>) -> ParseError {
let (line, col) = at.map(|t| (t.line, t.col)).unwrap_or(self.end);
ParseError {
message: message.into(),
line,
col,
}
}
fn expect(&mut self, expected: &Token, what: &str) -> Result<SpannedToken, ParseError> {
match self.next() {
Some(t) if &t.token == expected => Ok(t),
Some(t) => Err(ParseError {
message: format!("expected {what}, found '{}'", t.token),
line: t.line,
col: t.col,
}),
None => Err(self.error_at(format!("expected {what}, found end of input"), None)),
}
}
pub(crate) fn expect_eof(&mut self) -> Result<(), ParseError> {
match self.peek() {
None => Ok(()),
Some(t) => Err(ParseError {
message: format!("unexpected trailing token '{}'", t.token),
line: t.line,
col: t.col,
}),
}
}
pub(crate) fn parse_pipeline(&mut self) -> Result<Vec<PipelineStage>, ParseError> {
let mut stages = Vec::new();
loop {
match self.peek().map(|t| &t.token) {
Some(Token::PipeExact) => {
self.next();
stages.push(PipelineStage::LineFilter(
self.parse_line_filter_value(LineFilterOp::Contains)?,
));
}
Some(Token::PipeRegex) => {
self.next();
stages.push(PipelineStage::LineFilter(
self.parse_line_filter_value(LineFilterOp::Regex)?,
));
}
Some(Token::Neq) => {
self.next();
stages.push(PipelineStage::LineFilter(
self.parse_line_filter_value(LineFilterOp::NotContains)?,
));
}
Some(Token::Nre) => {
self.next();
stages.push(PipelineStage::LineFilter(
self.parse_line_filter_value(LineFilterOp::NotRegex)?,
));
}
Some(Token::Pipe) => {
self.next();
stages.push(self.parse_pipe_stage()?);
}
_ => break,
}
}
Ok(stages)
}
fn parse_line_filter_value(&mut self, op: LineFilterOp) -> Result<LineFilter, ParseError> {
if self.eat_ip_ident() {
let value = self.parse_ip_call()?;
return Ok(LineFilter {
op,
value,
is_ip: true,
});
}
match self.next() {
Some(t) => match t.token {
Token::String(value) => Ok(LineFilter {
op,
value,
is_ip: false,
}),
ref other => Err(self.error_at(
format!("expected a quoted string or ip() after line filter, found '{other}'"),
Some(&t),
)),
},
None => Err(self.error_at("expected a quoted string or ip() after line filter", None)),
}
}
fn eat_comma(&mut self) -> bool {
let is_comma = matches!(self.peek().map(|t| &t.token), Some(Token::Comma));
if is_comma {
self.next();
}
is_comma
}
fn eat_ip_ident(&mut self) -> bool {
let is_ip = matches!(
self.peek().map(|t| &t.token),
Some(Token::Ident(name)) if name == "ip"
);
if is_ip {
self.next();
}
is_ip
}
fn parse_ip_call(&mut self) -> Result<String, ParseError> {
self.expect(&Token::LParen, "'(' after ip")?;
let value = self.expect_string("an IP pattern string")?;
self.expect(&Token::RParen, "')' to close ip(...)")?;
Ok(value)
}
fn parse_pipe_stage(&mut self) -> Result<PipelineStage, ParseError> {
if let Some(t) = self.peek()
&& t.token == Token::Unwrap
{
self.next();
return Ok(PipelineStage::Unwrap(self.parse_unwrap()?));
}
if matches!(self.peek().map(|t| &t.token), Some(Token::LParen)) {
return Ok(PipelineStage::LabelFilter(self.parse_label_filter_expr()?));
}
let head = match self.peek() {
Some(t) => match &t.token {
Token::Ident(name) => name.clone(),
other => {
return Err(self.error_at(
format!("expected a pipeline stage after '|', found '{other}'"),
Some(t),
));
}
},
None => return Err(self.error_at("expected a pipeline stage after '|'", None)),
};
match head.as_str() {
"json" => {
self.next();
Ok(PipelineStage::Json(self.parse_label_extractions()?))
}
"logfmt" => {
self.next();
let flags = self.parse_flags();
let extractions = self.parse_label_extractions()?;
Ok(PipelineStage::Logfmt(LogfmtStage { flags, extractions }))
}
"regexp" => {
self.next();
Ok(PipelineStage::Regexp(
self.expect_string("a regexp pattern")?,
))
}
"pattern" => {
self.next();
Ok(PipelineStage::Pattern(
self.expect_string("a pattern string")?,
))
}
"unpack" => {
self.next();
Ok(PipelineStage::Unpack)
}
"decolorize" => {
self.next();
Ok(PipelineStage::Decolorize)
}
"distinct" => {
self.next();
Ok(PipelineStage::Distinct(self.parse_label_name_list()?))
}
"line_format" => {
self.next();
Ok(PipelineStage::LineFormat(
self.expect_string("a line_format template")?,
))
}
"label_format" => {
self.next();
Ok(PipelineStage::LabelFormat(self.parse_label_formats()?))
}
"drop" => {
self.next();
Ok(PipelineStage::Drop(self.parse_label_predicate_list()?))
}
"keep" => {
self.next();
Ok(PipelineStage::Keep(self.parse_label_predicate_list()?))
}
_ => Ok(PipelineStage::LabelFilter(self.parse_label_filter_expr()?)),
}
}
fn expect_string(&mut self, what: &str) -> Result<String, ParseError> {
match self.next() {
Some(t) => match t.token {
Token::String(value) => Ok(value),
ref other => {
Err(self.error_at(format!("expected {what}, found '{other}'"), Some(&t)))
}
},
None => Err(self.error_at(format!("expected {what}, found end of input"), None)),
}
}
fn expect_ident(&mut self, what: &str) -> Result<String, ParseError> {
match self.next() {
Some(t) => match &t.token {
Token::Ident(name) => Ok(name.clone()),
other if let Some(kw) = Token::keyword_text(other) => Ok(kw.to_string()),
other => Err(self.error_at(format!("expected {what}, found '{other}'"), Some(&t))),
},
None => Err(self.error_at(format!("expected {what}, found end of input"), None)),
}
}
fn parse_label_extractions(&mut self) -> Result<Vec<LabelExtraction>, ParseError> {
let mut out = Vec::new();
if !matches!(self.peek().map(|t| &t.token), Some(Token::Ident(_))) {
return Ok(out);
}
loop {
let name = self.expect_ident("a label name")?;
let expr = if matches!(self.peek().map(|t| &t.token), Some(Token::Eq)) {
self.next();
Some(self.expect_string("an extraction expression")?)
} else {
None
};
out.push(LabelExtraction { name, expr });
if !self.eat_comma() {
break;
}
}
Ok(out)
}
fn parse_label_formats(&mut self) -> Result<Vec<LabelFormat>, ParseError> {
let mut out = Vec::new();
loop {
let dst = self.expect_ident("a destination label")?;
self.expect(&Token::Eq, "'=' in label_format assignment")?;
let value = match self.next() {
Some(t) => match t.token {
Token::String(tmpl) => LabelFormatValue::Template(tmpl),
Token::Ident(src) => LabelFormatValue::Rename(src),
ref other => {
return Err(self.error_at(
format!("expected a source label or template string, found '{other}'"),
Some(&t),
));
}
},
None => {
return Err(self.error_at("expected a source label or template string", None));
}
};
out.push(LabelFormat { dst, value });
if !self.eat_comma() {
break;
}
}
Ok(out)
}
fn parse_label_name_list(&mut self) -> Result<Vec<String>, ParseError> {
let mut out = vec![self.expect_ident("a label name")?];
while self.eat_comma() {
out.push(self.expect_ident("a label name")?);
}
Ok(out)
}
fn parse_flags(&mut self) -> Vec<String> {
let mut flags = Vec::new();
while let Some(Token::Flag(name)) = self.peek().map(|t| &t.token) {
flags.push(name.clone());
self.next();
}
flags
}
fn parse_label_predicate_list(&mut self) -> Result<Vec<LabelPredicate>, ParseError> {
let mut out = vec![self.parse_label_predicate()?];
while self.eat_comma() {
out.push(self.parse_label_predicate()?);
}
Ok(out)
}
fn parse_label_predicate(&mut self) -> Result<LabelPredicate, ParseError> {
let name = self.expect_ident("a label name")?;
let matcher = match self.peek().map(|t| &t.token) {
Some(Token::Eq | Token::Neq | Token::Re | Token::Nre) => {
let tok = self.next().expect("peeked");
let op = token_to_match_op(&tok.token).expect("peeked matcher token");
let value = self.expect_string("a quoted matcher value")?;
Some((op, value))
}
_ => None,
};
Ok(LabelPredicate { name, matcher })
}
fn parse_unwrap(&mut self) -> Result<Unwrap, ParseError> {
let first = self.expect_ident("a label to unwrap")?;
if matches!(self.peek().map(|t| &t.token), Some(Token::LParen)) {
self.next();
let label = self.expect_ident("a label inside the conversion")?;
self.expect(&Token::RParen, "')' to close the unwrap conversion")?;
Ok(Unwrap {
label,
conversion: Some(first),
})
} else {
Ok(Unwrap {
label: first,
conversion: None,
})
}
}
fn parse_label_filter_expr(&mut self) -> Result<LabelFilterExpr, ParseError> {
let mut left = self.parse_label_filter_and()?;
while matches!(self.peek().map(|t| &t.token), Some(Token::Or)) {
self.next();
let right = self.parse_label_filter_and()?;
left = LabelFilterExpr::Or(Box::new(left), Box::new(right));
}
Ok(left)
}
fn parse_label_filter_and(&mut self) -> Result<LabelFilterExpr, ParseError> {
let mut left = self.parse_label_filter_primary()?;
while matches!(
self.peek().map(|t| &t.token),
Some(Token::And) | Some(Token::Comma)
) {
self.next();
let right = self.parse_label_filter_primary()?;
left = LabelFilterExpr::And(Box::new(left), Box::new(right));
}
Ok(left)
}
fn parse_label_filter_primary(&mut self) -> Result<LabelFilterExpr, ParseError> {
if matches!(self.peek().map(|t| &t.token), Some(Token::LParen)) {
self.next();
let expr = self.parse_label_filter_expr()?;
self.expect(&Token::RParen, "')' to close a label filter group")?;
return Ok(expr);
}
self.parse_label_filter_pred()
}
fn parse_label_filter_pred(&mut self) -> Result<LabelFilterExpr, ParseError> {
let name = self.expect_ident("a label name")?;
let (op_token, op) = match self.next() {
Some(t) => {
let op = match t.token {
Token::Eq => FilterOp::Eq,
Token::Neq => FilterOp::Neq,
Token::Re => FilterOp::Re,
Token::Nre => FilterOp::Nre,
Token::CmpEq => FilterOp::CmpEq,
Token::Gt => FilterOp::Gt,
Token::Gte => FilterOp::Gte,
Token::Lt => FilterOp::Lt,
Token::Lte => FilterOp::Lte,
ref other => {
return Err(self.error_at(
format!(
"expected a comparison operator in label filter, found '{other}'"
),
Some(&t),
));
}
};
(t, op)
}
None => {
return Err(self.error_at("expected a comparison operator in label filter", None));
}
};
let value = self.parse_filter_value()?;
self.check_op_value(op, &value, &op_token)?;
Ok(LabelFilterExpr::Pred(LabelFilterPred { name, op, value }))
}
fn parse_filter_value(&mut self) -> Result<FilterValue, ParseError> {
if self.eat_ip_ident() {
return Ok(FilterValue::Ip(self.parse_ip_call()?));
}
match self.next() {
Some(t) => match t.token {
Token::String(s) => Ok(FilterValue::String(s)),
Token::Number(n) => Ok(FilterValue::Number(n)),
Token::Duration(d) => Ok(FilterValue::Duration(d)),
Token::Bytes(b) => Ok(FilterValue::Bytes(b)),
ref other => Err(self.error_at(
format!(
"expected a string, number, duration, bytes, or ip() in label filter, found '{other}'"
),
Some(&t),
)),
},
None => Err(self.error_at("expected a value in label filter", None)),
}
}
fn check_op_value(
&self,
op: FilterOp,
value: &FilterValue,
op_token: &SpannedToken,
) -> Result<(), ParseError> {
let ok = match op {
FilterOp::Re | FilterOp::Nre => {
matches!(value, FilterValue::String(_) | FilterValue::Ip(_))
}
FilterOp::Gt | FilterOp::Gte | FilterOp::Lt | FilterOp::Lte => {
matches!(
value,
FilterValue::Number(_) | FilterValue::Duration(_) | FilterValue::Bytes(_)
)
}
FilterOp::Eq | FilterOp::Neq | FilterOp::CmpEq => true,
};
if ok {
Ok(())
} else {
Err(self.error_at(
format!(
"operator '{}' is not valid for this value type",
op_token.token
),
Some(op_token),
))
}
}
pub(crate) fn parse_selector(&mut self) -> Result<StreamSelector, ParseError> {
self.expect(&Token::LBrace, "'{' to start a stream selector")?;
let mut matchers = Vec::new();
loop {
match self.peek() {
Some(t) if t.token == Token::RBrace => {
self.next();
break;
}
Some(_) => {
matchers.push(self.parse_matcher()?);
match self.next() {
Some(t) if t.token == Token::Comma => continue,
Some(t) if t.token == Token::RBrace => break,
Some(t) => {
return Err(self.error_at(
format!(
"expected ',' or '}}' in stream selector, found '{}'",
t.token
),
Some(&t),
));
}
None => {
return Err(
self.error_at("unclosed stream selector (missing '}')", None)
);
}
}
}
None => {
return Err(self.error_at("unclosed stream selector (missing '}')", None));
}
}
}
Ok(StreamSelector { matchers })
}
fn parse_matcher(&mut self) -> Result<LabelMatcher, ParseError> {
let name = self.expect_ident("label name")?;
let op = match self.next() {
Some(t) => match token_to_match_op(&t.token) {
Some(op) => op,
None => {
return Err(self.error_at(
format!(
"expected matcher operator (=, !=, =~, !~), found '{}'",
t.token
),
Some(&t),
));
}
},
None => {
return Err(self.error_at("expected matcher operator, found end of input", None));
}
};
let value = match self.next() {
Some(t) => match t.token {
Token::String(value) => value,
ref other => {
return Err(self.error_at(
format!("expected quoted label value, found '{other}'"),
Some(&t),
));
}
},
None => return Err(self.error_at("expected label value, found end of input", None)),
};
Ok(LabelMatcher { name, op, value })
}
fn parse_metric_expr(&mut self) -> Result<MetricQuery, ParseError> {
self.parse_binary(0)
}
fn parse_binary(&mut self, min_prec: u8) -> Result<MetricQuery, ParseError> {
let mut left = self.parse_metric_unary()?;
while let Some((op, prec, right_assoc)) = self.peek_binary_op() {
if prec < min_prec {
break;
}
self.next();
let bool_modifier = if is_comparison(op)
&& matches!(self.peek().map(|t| &t.token), Some(Token::Bool))
{
self.next();
true
} else {
false
};
let matching = self.parse_optional_vector_match()?;
let next_min = if right_assoc { prec } else { prec + 1 };
let right = self.parse_binary(next_min)?;
left = MetricQuery::Binary(Box::new(BinaryExpr {
op,
left,
right,
bool_modifier,
matching,
}));
}
Ok(left)
}
fn parse_optional_vector_match(&mut self) -> Result<Option<VectorMatch>, ParseError> {
let on = match self.peek().map(|t| &t.token) {
Some(Token::On) => true,
Some(Token::Ignoring) => false,
_ => return Ok(None),
};
self.next();
let labels = self.parse_label_paren_list("on/ignoring")?;
let grouped = match self.peek().map(|t| &t.token) {
Some(Token::GroupLeft | Token::GroupRight) => {
self.next();
if matches!(self.peek().map(|t| &t.token), Some(Token::LParen)) {
self.parse_label_paren_list("group_left/group_right")?;
}
true
}
_ => false,
};
Ok(Some(VectorMatch {
on,
labels,
grouped,
}))
}
fn parse_label_paren_list(&mut self, what: &str) -> Result<Vec<String>, ParseError> {
self.expect(&Token::LParen, "'(' after label-list clause")?;
let mut labels = Vec::new();
if !matches!(self.peek().map(|t| &t.token), Some(Token::RParen)) {
loop {
labels.push(self.expect_ident(what)?);
if !self.eat_comma() {
break;
}
}
}
self.expect(&Token::RParen, "')' to close label list")?;
Ok(labels)
}
fn peek_binary_op(&self) -> Option<(BinOp, u8, bool)> {
let op = match self.peek().map(|t| &t.token)? {
Token::Or => (BinOp::Or, 1, false),
Token::And => (BinOp::And, 2, false),
Token::Unless => (BinOp::Unless, 2, false),
Token::CmpEq => (BinOp::Eq, 3, false),
Token::Neq => (BinOp::Neq, 3, false),
Token::Gt => (BinOp::Gt, 3, false),
Token::Gte => (BinOp::Gte, 3, false),
Token::Lt => (BinOp::Lt, 3, false),
Token::Lte => (BinOp::Lte, 3, false),
Token::Add => (BinOp::Add, 4, false),
Token::Sub => (BinOp::Sub, 4, false),
Token::Mul => (BinOp::Mul, 5, false),
Token::Div => (BinOp::Div, 5, false),
Token::Mod => (BinOp::Mod, 5, false),
Token::Pow => (BinOp::Pow, 6, true),
_ => return None,
};
Some(op)
}
fn parse_metric_unary(&mut self) -> Result<MetricQuery, ParseError> {
if matches!(self.peek().map(|t| &t.token), Some(Token::Sub)) {
self.next();
let inner = self.parse_metric_unary()?;
return Ok(MetricQuery::Binary(Box::new(BinaryExpr {
op: BinOp::Sub,
left: MetricQuery::Literal(0.0),
right: inner,
bool_modifier: false,
matching: None,
})));
}
if matches!(self.peek().map(|t| &t.token), Some(Token::Add)) {
self.next();
return self.parse_metric_unary();
}
self.parse_metric_atom()
}
fn parse_metric_atom(&mut self) -> Result<MetricQuery, ParseError> {
match self.peek().map(|t| &t.token) {
Some(Token::LParen) => {
self.next();
let inner = self.parse_metric_expr()?;
self.expect(&Token::RParen, "')' to close a parenthesized expression")?;
Ok(inner)
}
Some(Token::Number(n)) => {
let n = *n;
self.next();
Ok(MetricQuery::Literal(n))
}
Some(Token::Ident(name)) => {
let name = name.clone();
if RangeFunction::from_name(&name).is_some() {
self.parse_range_aggregation()
} else if AggregationFunction::from_name(&name).is_some() {
self.parse_vector_aggregation()
} else if name == "vector" {
self.parse_vector_literal()
} else if name == "label_replace" {
self.parse_label_replace()
} else {
let t = self.peek().cloned();
Err(self.error_at(format!("unknown metric function '{name}'"), t.as_ref()))
}
}
_ => {
let t = self.peek().cloned();
Err(self.error_at("expected a metric query", t.as_ref()))
}
}
}
fn parse_range_aggregation(&mut self) -> Result<MetricQuery, ParseError> {
let name = self.expect_ident("a range function")?;
let function = RangeFunction::from_name(&name).expect("checked by caller");
self.expect(&Token::LParen, "'(' after a range function")?;
let param =
self.parse_optional_scalar_param(function.takes_param(), "the range function")?;
let (log_query, range, mut offset, unwrap) = self.parse_log_range_expr()?;
self.expect(&Token::RParen, "')' to close the range aggregation")?;
if offset.is_none() {
offset = self.parse_optional_offset()?;
}
let grouping = self.parse_optional_grouping()?;
Ok(MetricQuery::Range(Box::new(RangeAggregation {
function,
log_query,
range,
offset,
unwrap,
param,
grouping,
})))
}
fn parse_vector_literal(&mut self) -> Result<MetricQuery, ParseError> {
self.expect_ident("vector")?;
self.expect(&Token::LParen, "'(' after vector")?;
let value = self.parse_number("a scalar value")?;
self.expect(&Token::RParen, "')' to close vector(...)")?;
Ok(MetricQuery::VectorLiteral(value))
}
fn parse_label_replace(&mut self) -> Result<MetricQuery, ParseError> {
self.expect_ident("label_replace")?;
self.expect(&Token::LParen, "'(' after label_replace")?;
let inner = self.parse_metric_expr()?;
self.expect(&Token::Comma, "',' after the label_replace vector")?;
let dst_label = self.expect_string("the destination label")?;
self.expect(&Token::Comma, "',' after the destination label")?;
let replacement = self.expect_string("the replacement template")?;
self.expect(&Token::Comma, "',' after the replacement")?;
let src_label = self.expect_string("the source label")?;
self.expect(&Token::Comma, "',' after the source label")?;
let regex = self.expect_string("the regex")?;
self.expect(&Token::RParen, "')' to close label_replace(...)")?;
Ok(MetricQuery::LabelReplace(Box::new(
crate::metric::LabelReplace {
inner,
dst_label,
replacement,
src_label,
regex,
},
)))
}
fn parse_log_range_expr(
&mut self,
) -> Result<
(
LogQuery,
std::time::Duration,
Option<std::time::Duration>,
Option<Unwrap>,
),
ParseError,
> {
let paren = matches!(self.peek().map(|t| &t.token), Some(Token::LParen));
if paren {
self.next();
}
let selector = self.parse_selector()?;
let mut pipeline = self.parse_pipeline()?;
if paren {
self.expect(
&Token::RParen,
"')' to close the parenthesized log expression",
)?;
}
let range = self.parse_range_window()?;
let offset = self.parse_optional_offset()?;
let unwrap = match pipeline.last() {
Some(PipelineStage::Unwrap(_)) => {
let Some(PipelineStage::Unwrap(u)) = pipeline.pop() else {
unreachable!()
};
Some(u)
}
_ => None,
};
Ok((
LogQuery {
selector: selector.clone(),
pipeline,
},
range,
offset,
unwrap,
))
}
fn parse_range_window(&mut self) -> Result<std::time::Duration, ParseError> {
self.expect(&Token::LBracket, "'[' to start a range window")?;
let range = match self.next() {
Some(t) => match t.token {
Token::Duration(d) => d,
ref other => {
return Err(self.error_at(
format!("expected a range duration, found '{other}'"),
Some(&t),
));
}
},
None => return Err(self.error_at("expected a range duration", None)),
};
self.expect(&Token::RBracket, "']' to close a range window")?;
Ok(range)
}
fn parse_optional_offset(&mut self) -> Result<Option<std::time::Duration>, ParseError> {
if !matches!(self.peek().map(|t| &t.token), Some(Token::Offset)) {
return Ok(None);
}
self.next();
match self.next() {
Some(t) => match t.token {
Token::Duration(d) => Ok(Some(d)),
ref other => Err(self.error_at(
format!("expected a duration after 'offset', found '{other}'"),
Some(&t),
)),
},
None => Err(self.error_at("expected a duration after 'offset'", None)),
}
}
fn parse_vector_aggregation(&mut self) -> Result<MetricQuery, ParseError> {
let name = self.expect_ident("an aggregation function")?;
let function = AggregationFunction::from_name(&name).expect("checked by caller");
let mut grouping = self.parse_optional_grouping()?;
self.expect(&Token::LParen, "'(' after an aggregation function")?;
let param = self.parse_optional_scalar_param(function.takes_param(), "the aggregation")?;
let inner = self.parse_metric_expr()?;
self.expect(&Token::RParen, "')' to close the aggregation")?;
if grouping.is_none() {
grouping = self.parse_optional_grouping()?;
}
Ok(MetricQuery::Vector(Box::new(VectorAggregation {
function,
param,
grouping,
inner,
})))
}
fn parse_optional_grouping(&mut self) -> Result<Option<Grouping>, ParseError> {
let without = match self.peek().map(|t| &t.token) {
Some(Token::By) => false,
Some(Token::Without) => true,
_ => return Ok(None),
};
self.next();
let labels = self.parse_label_paren_list("a grouping label")?;
Ok(Some(Grouping { without, labels }))
}
fn parse_number(&mut self, what: &str) -> Result<f64, ParseError> {
match self.next() {
Some(t) => match t.token {
Token::Number(n) => Ok(n),
ref other => {
Err(self.error_at(format!("expected {what}, found '{other}'"), Some(&t)))
}
},
None => Err(self.error_at(format!("expected {what}, found end of input"), None)),
}
}
fn parse_optional_scalar_param(
&mut self,
takes_param: bool,
what: &str,
) -> Result<Option<f64>, ParseError> {
if !takes_param {
return Ok(None);
}
let p = self.parse_number("a scalar parameter")?;
self.expect(&Token::Comma, &format!("',' after {what} parameter"))?;
Ok(Some(p))
}
}
fn token_to_match_op(token: &Token) -> Option<MatchOp> {
match token {
Token::Eq => Some(MatchOp::Eq),
Token::Neq => Some(MatchOp::Neq),
Token::Re => Some(MatchOp::Re),
Token::Nre => Some(MatchOp::Nre),
_ => None,
}
}
fn is_comparison(op: BinOp) -> bool {
matches!(
op,
BinOp::Eq | BinOp::Neq | BinOp::Gt | BinOp::Gte | BinOp::Lt | BinOp::Lte
)
}
#[cfg(test)]
mod tests {
use super::*;
fn matcher(name: &str, op: MatchOp, value: &str) -> LabelMatcher {
LabelMatcher {
name: name.to_string(),
op,
value: value.to_string(),
}
}
#[test]
fn parses_single_matcher() {
assert_eq!(
parse_selector(r#"{job="api"}"#).unwrap().matchers,
vec![matcher("job", MatchOp::Eq, "api")]
);
}
#[test]
fn parses_multiple_matchers_with_all_operators() {
assert_eq!(
parse_selector(
r#"{service_name="frontend", level!="debug", namespace=~"prod-.*", env!~"dev.*"}"#
)
.unwrap()
.matchers,
vec![
matcher("service_name", MatchOp::Eq, "frontend"),
matcher("level", MatchOp::Neq, "debug"),
matcher("namespace", MatchOp::Re, "prod-.*"),
matcher("env", MatchOp::Nre, "dev.*"),
]
);
}
#[test]
fn parses_empty_selector_and_trailing_comma() {
assert!(parse_selector("{}").unwrap().matchers.is_empty());
assert_eq!(parse_selector(r#"{job="api",}"#).unwrap().matchers.len(), 1);
}
#[test]
fn dotted_matcher_name_parses() {
assert_eq!(
parse_selector(r#"{k8s.pod.name="x", level="error"}"#)
.unwrap()
.matchers,
vec![
matcher("k8s.pod.name", MatchOp::Eq, "x"),
matcher("level", MatchOp::Eq, "error"),
]
);
}
#[test]
fn keywords_are_valid_label_names() {
assert_eq!(
parse_selector(r#"{by="x", offset!="y"}"#).unwrap().matchers,
vec![
matcher("by", MatchOp::Eq, "x"),
matcher("offset", MatchOp::Neq, "y"),
]
);
}
#[test]
fn parse_query_returns_empty_pipeline() {
let query = parse_query(r#"{job="api"}"#).unwrap();
assert_eq!(query.selector.matchers.len(), 1);
assert!(query.pipeline.is_empty());
}
#[test]
fn parse_query_parses_a_line_filter_pipeline() {
let query = parse_query(r#"{job="api"} |= "error""#).unwrap();
assert_eq!(query.selector.matchers.len(), 1);
assert_eq!(
query.pipeline,
vec![PipelineStage::LineFilter(LineFilter {
op: LineFilterOp::Contains,
value: "error".to_string(),
is_ip: false,
})]
);
}
#[test]
fn rejects_missing_brace() {
let err = parse_selector(r#"{job="api""#).unwrap_err();
assert!(err.message.contains("missing '}'"), "{err}");
}
#[test]
fn rejects_missing_operator_and_value() {
let err = parse_selector(r#"{job}"#).unwrap_err();
assert!(err.message.contains("matcher operator"), "{err}");
let err = parse_selector(r#"{job=}"#).unwrap_err();
assert!(err.message.contains("quoted label value"), "{err}");
let err = parse_selector(r#"{job=api}"#).unwrap_err();
assert!(err.message.contains("quoted label value"), "{err}");
}
#[test]
fn rejects_missing_selector() {
let err = parse_selector(r#"job="api""#).unwrap_err();
assert!(err.message.contains("'{'"), "{err}");
}
#[test]
fn error_positions_point_at_offending_token() {
let err = parse_selector("{job =\n 5}").unwrap_err();
assert_eq!((err.line, err.col), (2, 3));
}
#[test]
fn lex_errors_propagate_with_position() {
let err = parse_selector(r#"{job="unterminated}"#).unwrap_err();
assert!(err.message.contains("unterminated"), "{err}");
}
fn pipeline(input: &str) -> Vec<PipelineStage> {
parse_query(input).expect("parse").pipeline
}
fn line(op: LineFilterOp, value: &str) -> PipelineStage {
PipelineStage::LineFilter(LineFilter {
op,
value: value.to_string(),
is_ip: false,
})
}
#[test]
fn parses_all_line_filter_operators() {
assert_eq!(
pipeline(r#"{a="b"} |= "keep" != "drop" |~ "re" !~ "nre""#),
vec![
line(LineFilterOp::Contains, "keep"),
line(LineFilterOp::NotContains, "drop"),
line(LineFilterOp::Regex, "re"),
line(LineFilterOp::NotRegex, "nre"),
]
);
}
#[test]
fn parses_json_and_logfmt_with_and_without_extractions() {
assert_eq!(
pipeline(r#"{a="b"} | json"#),
vec![PipelineStage::Json(vec![])]
);
assert_eq!(
pipeline(r#"{a="b"} | json status="response.status", method"#),
vec![PipelineStage::Json(vec![
LabelExtraction {
name: "status".into(),
expr: Some("response.status".into()),
},
LabelExtraction {
name: "method".into(),
expr: None,
},
])]
);
assert_eq!(
pipeline(r#"{a="b"} | logfmt"#),
vec![PipelineStage::Logfmt(LogfmtStage::default())]
);
}
#[test]
fn parses_logfmt_flags() {
assert_eq!(
pipeline(r#"{a="b"} | logfmt --strict --keep-empty host"#),
vec![PipelineStage::Logfmt(LogfmtStage {
flags: vec!["strict".into(), "keep-empty".into()],
extractions: vec![LabelExtraction {
name: "host".into(),
expr: None,
}],
})]
);
}
#[test]
fn parses_decolorize_and_distinct() {
assert_eq!(
pipeline(r#"{a="b"} | decolorize"#),
vec![PipelineStage::Decolorize]
);
assert_eq!(
pipeline(r#"{a="b"} | distinct host, path"#),
vec![PipelineStage::Distinct(vec!["host".into(), "path".into()])]
);
}
#[test]
fn parses_ip_line_and_label_filters() {
assert_eq!(
pipeline(r#"{a="b"} |= ip("192.168.4.5/16")"#),
vec![PipelineStage::LineFilter(LineFilter {
op: LineFilterOp::Contains,
value: "192.168.4.5/16".into(),
is_ip: true,
})]
);
assert_eq!(
pipeline(r#"{a="b"} | logfmt | addr = ip("10.0.0.0/8")"#),
vec![
PipelineStage::Logfmt(LogfmtStage::default()),
PipelineStage::LabelFilter(LabelFilterExpr::Pred(LabelFilterPred {
name: "addr".into(),
op: FilterOp::Eq,
value: FilterValue::Ip("10.0.0.0/8".into()),
})),
]
);
}
#[test]
fn parses_bytes_label_filter() {
assert_eq!(
pipeline(r#"{a="b"} | logfmt | size > 20KB"#),
vec![
PipelineStage::Logfmt(LogfmtStage::default()),
PipelineStage::LabelFilter(LabelFilterExpr::Pred(LabelFilterPred {
name: "size".into(),
op: FilterOp::Gt,
value: FilterValue::Bytes(20_000),
})),
]
);
}
#[test]
fn parses_parenthesized_label_filter() {
let stages = pipeline(r#"{x="y"} | (a="1" or b="2") and c="3""#);
let PipelineStage::LabelFilter(LabelFilterExpr::And(left, right)) = &stages[0] else {
panic!("expected top-level And, got {:?}", stages[0]);
};
assert!(matches!(**left, LabelFilterExpr::Or(_, _)));
assert!(matches!(**right, LabelFilterExpr::Pred(_)));
}
#[test]
fn parses_drop_keep_with_matchers() {
assert_eq!(
pipeline(r#"{a="b"} | json | drop __error__, method="GET""#),
vec![
PipelineStage::Json(vec![]),
PipelineStage::Drop(vec![
LabelPredicate {
name: "__error__".into(),
matcher: None,
},
LabelPredicate {
name: "method".into(),
matcher: Some((MatchOp::Eq, "GET".into())),
},
]),
]
);
}
#[test]
fn parses_regexp_pattern_unpack() {
assert_eq!(
pipeline(r#"{a="b"} | regexp "(?P<method>\\w+)""#),
vec![PipelineStage::Regexp(r"(?P<method>\w+)".into())]
);
assert_eq!(
pipeline(r#"{a="b"} | pattern "<method> <path>""#),
vec![PipelineStage::Pattern("<method> <path>".into())]
);
assert_eq!(pipeline(r#"{a="b"} | unpack"#), vec![PipelineStage::Unpack]);
}
#[test]
fn parses_formatters() {
assert_eq!(
pipeline(r#"{a="b"} | line_format "{{.msg}}""#),
vec![PipelineStage::LineFormat("{{.msg}}".into())]
);
assert_eq!(
pipeline(r#"{a="b"} | label_format dst="{{.src}}", renamed=original"#),
vec![PipelineStage::LabelFormat(vec![
LabelFormat {
dst: "dst".into(),
value: LabelFormatValue::Template("{{.src}}".into()),
},
LabelFormat {
dst: "renamed".into(),
value: LabelFormatValue::Rename("original".into()),
},
])]
);
}
#[test]
fn parses_drop_and_keep() {
let bare = |name: &str| LabelPredicate {
name: name.to_string(),
matcher: None,
};
assert_eq!(
pipeline(r#"{a="b"} | drop level, source"#),
vec![PipelineStage::Drop(vec![bare("level"), bare("source")])]
);
assert_eq!(
pipeline(r#"{a="b"} | keep pod"#),
vec![PipelineStage::Keep(vec![bare("pod")])]
);
}
#[test]
fn parses_unwrap_forms() {
assert_eq!(
pipeline(r#"{a="b"} | unwrap duration_ms"#),
vec![PipelineStage::Unwrap(Unwrap {
label: "duration_ms".into(),
conversion: None,
})]
);
assert_eq!(
pipeline(r#"{a="b"} | unwrap duration(latency)"#),
vec![PipelineStage::Unwrap(Unwrap {
label: "latency".into(),
conversion: Some("duration".into()),
})]
);
}
#[test]
fn parses_label_filter_string_and_numeric() {
assert_eq!(
pipeline(r#"{a="b"} | level="error""#),
vec![PipelineStage::LabelFilter(LabelFilterExpr::Pred(
LabelFilterPred {
name: "level".into(),
op: FilterOp::Eq,
value: FilterValue::String("error".into()),
}
))]
);
assert_eq!(
pipeline(r#"{a="b"} | status >= 500"#),
vec![PipelineStage::LabelFilter(LabelFilterExpr::Pred(
LabelFilterPred {
name: "status".into(),
op: FilterOp::Gte,
value: FilterValue::Number(500.0),
}
))]
);
}
#[test]
fn parses_dotted_label_filter_name() {
assert_eq!(
pipeline(r#"{a="b"} | http.response.status_code >= 500"#),
vec![PipelineStage::LabelFilter(LabelFilterExpr::Pred(
LabelFilterPred {
name: "http.response.status_code".into(),
op: FilterOp::Gte,
value: FilterValue::Number(500.0),
}
))]
);
}
#[test]
fn label_filter_and_or_precedence() {
let stages = pipeline(r#"{x="y"} | a="1" and b="2" or c="3""#);
let PipelineStage::LabelFilter(expr) = &stages[0] else {
panic!("expected label filter");
};
match expr {
LabelFilterExpr::Or(left, right) => {
assert!(matches!(**left, LabelFilterExpr::And(_, _)));
assert!(matches!(**right, LabelFilterExpr::Pred(_)));
}
other => panic!("expected top-level Or, got {other:?}"),
}
}
#[test]
fn label_filter_comma_is_conjunction() {
let stages = pipeline(r#"{x="y"} | a="1", b="2""#);
let PipelineStage::LabelFilter(expr) = &stages[0] else {
panic!("expected label filter");
};
assert!(matches!(expr, LabelFilterExpr::And(_, _)));
}
#[test]
fn parses_full_pipeline_end_to_end() {
let query = parse_query(
r#"{app="api"} |= "error" | json | status >= 500 | line_format "{{.msg}}""#,
)
.unwrap();
assert_eq!(query.pipeline.len(), 4);
assert!(matches!(query.pipeline[0], PipelineStage::LineFilter(_)));
assert!(matches!(query.pipeline[1], PipelineStage::Json(_)));
assert!(matches!(query.pipeline[2], PipelineStage::LabelFilter(_)));
assert!(matches!(query.pipeline[3], PipelineStage::LineFormat(_)));
}
#[test]
fn duration_label_filter() {
assert_eq!(
pipeline(r#"{a="b"} | logfmt | latency > 1s"#),
vec![
PipelineStage::Logfmt(LogfmtStage::default()),
PipelineStage::LabelFilter(LabelFilterExpr::Pred(LabelFilterPred {
name: "latency".into(),
op: FilterOp::Gt,
value: FilterValue::Duration(std::time::Duration::from_secs(1)),
})),
]
);
}
#[test]
fn rejects_regex_operator_against_number() {
let err = parse_query(r#"{a="b"} | status =~ 500"#).unwrap_err();
assert!(
err.message.contains("not valid for this value type"),
"{err}"
);
}
#[test]
fn rejects_ordered_comparison_against_string() {
let err = parse_query(r#"{a="b"} | level > "error""#).unwrap_err();
assert!(
err.message.contains("not valid for this value type"),
"{err}"
);
}
#[test]
fn rejects_line_filter_without_string() {
let err = parse_query(r#"{a="b"} |= 5"#).unwrap_err();
assert!(err.message.contains("quoted string"), "{err}");
}
#[test]
fn rejects_dangling_pipe() {
let err = parse_query(r#"{a="b"} |"#).unwrap_err();
assert!(err.message.contains("pipeline stage after '|'"), "{err}");
}
use std::time::Duration;
fn metric(input: &str) -> MetricQuery {
parse_metric_query(input).expect("parse metric")
}
fn as_range(q: &MetricQuery) -> &RangeAggregation {
match q {
MetricQuery::Range(r) => r,
other => panic!("expected range aggregation, got {other:?}"),
}
}
fn as_vector(q: &MetricQuery) -> &VectorAggregation {
match q {
MetricQuery::Vector(v) => v,
other => panic!("expected vector aggregation, got {other:?}"),
}
}
fn as_binary(q: &MetricQuery) -> &BinaryExpr {
match q {
MetricQuery::Binary(b) => b,
other => panic!("expected binary expression, got {other:?}"),
}
}
#[test]
fn parses_on_and_ignoring_vector_matching() {
let on = metric(r#"sum(rate({a="b"}[1m])) / on(service) sum(rate({a="c"}[1m]))"#);
let m = as_binary(&on).matching.as_ref().expect("matching clause");
assert!(m.on);
assert_eq!(m.labels, vec!["service".to_string()]);
assert!(!m.grouped);
let ign = metric(r#"sum(rate({a="b"}[1m])) / ignoring(level) sum(rate({a="c"}[1m]))"#);
let m = as_binary(&ign).matching.as_ref().expect("matching clause");
assert!(!m.on);
assert_eq!(m.labels, vec!["level".to_string()]);
let grp =
metric(r#"sum(rate({a="b"}[1m])) / on(service) group_left sum(rate({a="c"}[1m]))"#);
assert!(as_binary(&grp).matching.as_ref().unwrap().grouped);
let plain = metric(r#"sum(rate({a="b"}[1m])) / sum(rate({a="c"}[1m]))"#);
assert!(as_binary(&plain).matching.is_none());
}
#[test]
fn parses_bare_range_aggregation() {
let q = metric(r#"rate({job="api"}[5m])"#);
let r = as_range(&q);
assert_eq!(r.function, RangeFunction::Rate);
assert_eq!(r.range, Duration::from_secs(300));
assert_eq!(r.log_query.selector.matchers.len(), 1);
assert!(r.log_query.pipeline.is_empty());
assert!(r.offset.is_none() && r.unwrap.is_none() && r.param.is_none());
}
#[test]
fn parses_range_aggregation_over_a_pipeline() {
let q = metric(r#"count_over_time({job="api"} |= "error" [1h])"#);
let r = as_range(&q);
assert_eq!(r.function, RangeFunction::CountOverTime);
assert_eq!(r.range, Duration::from_secs(3600));
assert_eq!(r.log_query.pipeline.len(), 1);
assert!(matches!(
r.log_query.pipeline[0],
PipelineStage::LineFilter(_)
));
}
#[test]
fn parses_every_range_function_name() {
for (name, func) in [
("rate", RangeFunction::Rate),
("rate_counter", RangeFunction::RateCounter),
("count_over_time", RangeFunction::CountOverTime),
("bytes_rate", RangeFunction::BytesRate),
("bytes_over_time", RangeFunction::BytesOverTime),
("first_over_time", RangeFunction::FirstOverTime),
("last_over_time", RangeFunction::LastOverTime),
("absent_over_time", RangeFunction::AbsentOverTime),
] {
let q = metric(&format!(r#"{name}({{a="b"}}[5m])"#));
assert_eq!(as_range(&q).function, func, "{name}");
}
}
#[test]
fn parses_offset_modifier() {
let q = metric(r#"rate({a="b"}[5m] offset 1h)"#);
let r = as_range(&q);
assert_eq!(r.offset, Some(Duration::from_secs(3600)));
}
#[test]
fn parses_unwrap_range_aggregation() {
let q = metric(r#"avg_over_time({job="api"} | json | unwrap duration [5m])"#);
let r = as_range(&q);
assert_eq!(r.function, RangeFunction::AvgOverTime);
assert_eq!(
r.unwrap,
Some(Unwrap {
label: "duration".into(),
conversion: None,
})
);
assert_eq!(r.log_query.pipeline.len(), 1);
assert!(matches!(r.log_query.pipeline[0], PipelineStage::Json(_)));
}
#[test]
fn parses_quantile_over_time_param() {
let q = metric(r#"quantile_over_time(0.99, {a="b"} | unwrap latency [5m])"#);
let r = as_range(&q);
assert_eq!(r.function, RangeFunction::QuantileOverTime);
assert_eq!(r.param, Some(0.99));
assert_eq!(r.unwrap.as_ref().unwrap().label, "latency");
}
#[test]
fn parses_vector_aggregation_with_grouping() {
let q = metric(r#"sum by (level) (rate({job="api"}[5m]))"#);
let v = as_vector(&q);
assert_eq!(v.function, AggregationFunction::Sum);
assert_eq!(
v.grouping,
Some(Grouping {
without: false,
labels: vec!["level".into()],
})
);
assert!(matches!(v.inner, MetricQuery::Range(_)));
}
#[test]
fn parses_dotted_grouping_label() {
let q = metric(r#"sum by (k8s.pod.name) (count_over_time({level="error"}[5m]))"#);
let v = as_vector(&q);
assert_eq!(v.function, AggregationFunction::Sum);
assert_eq!(
v.grouping,
Some(Grouping {
without: false,
labels: vec!["k8s.pod.name".into()],
})
);
}
#[test]
fn parses_trailing_grouping() {
let q = metric(r#"sum(rate({a="b"}[5m])) without (pod, ns)"#);
let v = as_vector(&q);
assert_eq!(
v.grouping,
Some(Grouping {
without: true,
labels: vec!["pod".into(), "ns".into()],
})
);
}
#[test]
fn parses_topk_with_param_and_nested_aggregation() {
let q = metric(r#"topk(10, sum by (path) (rate({job="api"}[5m])))"#);
let v = as_vector(&q);
assert_eq!(v.function, AggregationFunction::Topk);
assert_eq!(v.param, Some(10.0));
let inner = as_vector(&v.inner);
assert_eq!(inner.function, AggregationFunction::Sum);
}
#[test]
fn parses_empty_grouping() {
let q = metric(r#"sum by () (rate({a="b"}[5m]))"#);
assert_eq!(
as_vector(&q).grouping.as_ref().unwrap().labels,
Vec::<String>::new()
);
}
#[test]
fn parses_binary_arithmetic_with_scalar() {
let q = metric(r#"rate({a="b"}[5m]) * 60"#);
let b = as_binary(&q);
assert_eq!(b.op, BinOp::Mul);
assert!(matches!(b.left, MetricQuery::Range(_)));
assert_eq!(b.right, MetricQuery::Literal(60.0));
}
#[test]
fn binary_operator_precedence() {
let q = metric(r#"rate({a="b"}[1m]) + rate({a="c"}[1m]) * 2"#);
let b = as_binary(&q);
assert_eq!(b.op, BinOp::Add);
assert_eq!(as_binary(&b.right).op, BinOp::Mul);
}
#[test]
fn pow_is_right_associative() {
let q = metric("2 ^ 3 ^ 2");
let b = as_binary(&q);
assert_eq!(b.op, BinOp::Pow);
assert_eq!(b.left, MetricQuery::Literal(2.0));
assert_eq!(as_binary(&b.right).op, BinOp::Pow);
}
#[test]
fn logical_operators_bind_loosest() {
let q =
metric(r#"rate({a="1"}[1m]) > 1 and rate({a="2"}[1m]) > 2 or rate({a="3"}[1m]) > 3"#);
let top = as_binary(&q);
assert_eq!(top.op, BinOp::Or);
assert_eq!(as_binary(&top.left).op, BinOp::And);
}
#[test]
fn parses_bool_modifier_on_comparison() {
let q = metric(r#"rate({a="b"}[5m]) > bool 5"#);
let b = as_binary(&q);
assert_eq!(b.op, BinOp::Gt);
assert!(b.bool_modifier);
assert_eq!(b.right, MetricQuery::Literal(5.0));
}
#[test]
fn parses_parenthesized_and_unary_minus() {
let q = metric(r#"(rate({a="b"}[5m]))"#);
assert!(matches!(q, MetricQuery::Range(_)));
let neg = metric(r#"- rate({a="b"}[5m])"#);
let b = as_binary(&neg);
assert_eq!(b.op, BinOp::Sub);
assert_eq!(b.left, MetricQuery::Literal(0.0));
}
#[test]
fn parse_dispatches_log_vs_metric() {
assert!(matches!(parse(r#"{job="api"}"#).unwrap(), Expr::Log(_)));
assert!(matches!(
parse(r#"{job="api"} |= "x""#).unwrap(),
Expr::Log(_)
));
assert!(matches!(
parse(r#"rate({job="api"}[5m])"#).unwrap(),
Expr::Metric(_)
));
assert!(matches!(
parse(r#"sum(rate({a="b"}[1m]))"#).unwrap(),
Expr::Metric(_)
));
}
#[test]
fn rejects_missing_range_window() {
let err = parse_metric_query(r#"rate({a="b"})"#).unwrap_err();
assert!(
err.message.contains("range window") || err.message.contains("'['"),
"{err}"
);
}
#[test]
fn rejects_unknown_metric_function() {
let err = parse_metric_query(r#"frobnicate({a="b"}[5m])"#).unwrap_err();
assert!(err.message.contains("unknown metric function"), "{err}");
}
#[test]
fn rejects_missing_quantile_param() {
let err = parse_metric_query(r#"quantile_over_time({a="b"} | unwrap x [5m])"#).unwrap_err();
assert!(
err.message.contains("scalar parameter") || err.message.contains("','"),
"{err}"
);
}
#[test]
fn rejects_unclosed_aggregation_paren() {
let err = parse_metric_query(r#"sum(rate({a="b"}[5m])"#).unwrap_err();
assert!(err.message.contains("')'"), "{err}");
}
#[test]
fn parses_offset_after_aggregation() {
let q = metric(r#"count_over_time({job="mysql"}[5m]) offset 5m"#);
assert_eq!(as_range(&q).offset, Some(Duration::from_secs(300)));
}
#[test]
fn parses_parenthesized_selector_in_range() {
let q = metric(r#"rate(({job="mysql"} |= "error" != "timeout")[10s])"#);
let r = as_range(&q);
assert_eq!(r.range, Duration::from_secs(10));
assert_eq!(r.log_query.pipeline.len(), 2);
}
#[test]
fn parses_vector_literal() {
assert_eq!(metric("vector(0)"), MetricQuery::VectorLiteral(0.0));
let q = metric(r#"sum(count_over_time({a="b"}[5m])) or vector(0)"#);
let b = as_binary(&q);
assert_eq!(b.op, BinOp::Or);
assert_eq!(b.right, MetricQuery::VectorLiteral(0.0));
}
#[test]
fn parses_label_replace() {
let q = metric(
r#"label_replace(sum(rate({job="api"}[5m])) by (instance), "host", "$1", "instance", "(.*):.*")"#,
);
let MetricQuery::LabelReplace(lr) = &q else {
panic!("expected label_replace, got {q:?}");
};
assert_eq!(lr.dst_label, "host");
assert_eq!(lr.replacement, "$1");
assert_eq!(lr.src_label, "instance");
assert_eq!(lr.regex, "(.*):.*");
assert!(matches!(lr.inner, MetricQuery::Vector(_)));
}
}