1use crate::ast::{
9 FilterOp, FilterValue, Grouping, LabelExtraction, LabelFilterExpr, LabelFilterPred,
10 LabelFormat, LabelFormatValue, LabelMatcher, LabelPredicate, LineFilter, LineFilterOp,
11 LogQuery, LogfmtStage, MatchOp, PipelineStage, StreamSelector, Unwrap,
12};
13use crate::lexer::{LexError, tokenize};
14use crate::metric::{
15 AggregationFunction, BinOp, BinaryExpr, MetricQuery, RangeAggregation, RangeFunction,
16 VectorAggregation, VectorMatch,
17};
18use crate::token::{SpannedToken, Token};
19
20#[derive(Debug, Clone, PartialEq)]
23#[non_exhaustive]
24pub enum Expr {
25 Log(LogQuery),
26 Metric(MetricQuery),
27}
28
29#[derive(Debug, Clone, PartialEq, thiserror::Error)]
33#[error("{message} at line {line}, column {col}")]
34#[non_exhaustive]
35pub struct ParseError {
36 pub message: String,
37 pub line: u32,
38 pub col: u32,
39}
40
41impl From<LexError> for ParseError {
42 fn from(e: LexError) -> Self {
43 Self {
44 message: e.message,
45 line: e.line,
46 col: e.col,
47 }
48 }
49}
50
51pub fn parse_query(input: &str) -> Result<LogQuery, ParseError> {
54 let mut parser = Parser::new(input)?;
55 let selector = parser.parse_selector()?;
56 let pipeline = parser.parse_pipeline()?;
57 parser.expect_eof()?;
58 Ok(LogQuery { selector, pipeline })
59}
60
61pub fn parse_selector(input: &str) -> Result<StreamSelector, ParseError> {
64 let mut parser = Parser::new(input)?;
65 let selector = parser.parse_selector()?;
66 parser.expect_eof()?;
67 Ok(selector)
68}
69
70pub fn parse(input: &str) -> Result<Expr, ParseError> {
75 let mut parser = Parser::new(input)?;
76 let expr = if matches!(parser.peek().map(|t| &t.token), Some(Token::LBrace)) {
77 let selector = parser.parse_selector()?;
78 let pipeline = parser.parse_pipeline()?;
79 Expr::Log(LogQuery { selector, pipeline })
80 } else {
81 Expr::Metric(parser.parse_metric_expr()?)
82 };
83 parser.expect_eof()?;
84 Ok(expr)
85}
86
87pub fn parse_metric_query(input: &str) -> Result<MetricQuery, ParseError> {
89 let mut parser = Parser::new(input)?;
90 let query = parser.parse_metric_expr()?;
91 parser.expect_eof()?;
92 Ok(query)
93}
94
95pub(crate) struct Parser {
96 tokens: Vec<SpannedToken>,
97 pos: usize,
98 end: (u32, u32),
100}
101
102impl Parser {
103 pub(crate) fn new(input: &str) -> Result<Self, ParseError> {
104 let tokens = tokenize(input)?;
105 let end = tokens
106 .last()
107 .map(|t| (t.line, t.col + t.token.to_string().len() as u32))
108 .unwrap_or((1, 1));
109 Ok(Self {
110 tokens,
111 pos: 0,
112 end,
113 })
114 }
115
116 fn peek(&self) -> Option<&SpannedToken> {
117 self.tokens.get(self.pos)
118 }
119
120 fn next(&mut self) -> Option<SpannedToken> {
121 let t = self.tokens.get(self.pos).cloned();
122 if t.is_some() {
123 self.pos += 1;
124 }
125 t
126 }
127
128 fn error_at(&self, message: impl Into<String>, at: Option<&SpannedToken>) -> ParseError {
129 let (line, col) = at.map(|t| (t.line, t.col)).unwrap_or(self.end);
130 ParseError {
131 message: message.into(),
132 line,
133 col,
134 }
135 }
136
137 fn expect(&mut self, expected: &Token, what: &str) -> Result<SpannedToken, ParseError> {
138 match self.next() {
139 Some(t) if &t.token == expected => Ok(t),
140 Some(t) => Err(ParseError {
141 message: format!("expected {what}, found '{}'", t.token),
142 line: t.line,
143 col: t.col,
144 }),
145 None => Err(self.error_at(format!("expected {what}, found end of input"), None)),
146 }
147 }
148
149 pub(crate) fn expect_eof(&mut self) -> Result<(), ParseError> {
150 match self.peek() {
151 None => Ok(()),
152 Some(t) => Err(ParseError {
153 message: format!("unexpected trailing token '{}'", t.token),
154 line: t.line,
155 col: t.col,
156 }),
157 }
158 }
159
160 pub(crate) fn parse_pipeline(&mut self) -> Result<Vec<PipelineStage>, ParseError> {
166 let mut stages = Vec::new();
167 loop {
168 match self.peek().map(|t| &t.token) {
169 Some(Token::PipeExact) => {
170 self.next();
171 stages.push(PipelineStage::LineFilter(
172 self.parse_line_filter_value(LineFilterOp::Contains)?,
173 ));
174 }
175 Some(Token::PipeRegex) => {
176 self.next();
177 stages.push(PipelineStage::LineFilter(
178 self.parse_line_filter_value(LineFilterOp::Regex)?,
179 ));
180 }
181 Some(Token::Neq) => {
182 self.next();
183 stages.push(PipelineStage::LineFilter(
184 self.parse_line_filter_value(LineFilterOp::NotContains)?,
185 ));
186 }
187 Some(Token::Nre) => {
188 self.next();
189 stages.push(PipelineStage::LineFilter(
190 self.parse_line_filter_value(LineFilterOp::NotRegex)?,
191 ));
192 }
193 Some(Token::Pipe) => {
194 self.next();
195 stages.push(self.parse_pipe_stage()?);
196 }
197 _ => break,
198 }
199 }
200 Ok(stages)
201 }
202
203 fn parse_line_filter_value(&mut self, op: LineFilterOp) -> Result<LineFilter, ParseError> {
205 if self.eat_ip_ident() {
207 let value = self.parse_ip_call()?;
208 return Ok(LineFilter {
209 op,
210 value,
211 is_ip: true,
212 });
213 }
214 match self.next() {
215 Some(t) => match t.token {
216 Token::String(value) => Ok(LineFilter {
217 op,
218 value,
219 is_ip: false,
220 }),
221 ref other => Err(self.error_at(
222 format!("expected a quoted string or ip() after line filter, found '{other}'"),
223 Some(&t),
224 )),
225 },
226 None => Err(self.error_at("expected a quoted string or ip() after line filter", None)),
227 }
228 }
229
230 fn eat_comma(&mut self) -> bool {
233 let is_comma = matches!(self.peek().map(|t| &t.token), Some(Token::Comma));
234 if is_comma {
235 self.next();
236 }
237 is_comma
238 }
239
240 fn eat_ip_ident(&mut self) -> bool {
243 let is_ip = matches!(
244 self.peek().map(|t| &t.token),
245 Some(Token::Ident(name)) if name == "ip"
246 );
247 if is_ip {
248 self.next();
249 }
250 is_ip
251 }
252
253 fn parse_ip_call(&mut self) -> Result<String, ParseError> {
255 self.expect(&Token::LParen, "'(' after ip")?;
256 let value = self.expect_string("an IP pattern string")?;
257 self.expect(&Token::RParen, "')' to close ip(...)")?;
258 Ok(value)
259 }
260
261 fn parse_pipe_stage(&mut self) -> Result<PipelineStage, ParseError> {
263 if let Some(t) = self.peek()
265 && t.token == Token::Unwrap
266 {
267 self.next();
268 return Ok(PipelineStage::Unwrap(self.parse_unwrap()?));
269 }
270
271 if matches!(self.peek().map(|t| &t.token), Some(Token::LParen)) {
273 return Ok(PipelineStage::LabelFilter(self.parse_label_filter_expr()?));
274 }
275
276 let head = match self.peek() {
277 Some(t) => match &t.token {
278 Token::Ident(name) => name.clone(),
279 other => {
280 return Err(self.error_at(
281 format!("expected a pipeline stage after '|', found '{other}'"),
282 Some(t),
283 ));
284 }
285 },
286 None => return Err(self.error_at("expected a pipeline stage after '|'", None)),
287 };
288
289 match head.as_str() {
290 "json" => {
291 self.next();
292 Ok(PipelineStage::Json(self.parse_label_extractions()?))
293 }
294 "logfmt" => {
295 self.next();
296 let flags = self.parse_flags();
297 let extractions = self.parse_label_extractions()?;
298 Ok(PipelineStage::Logfmt(LogfmtStage { flags, extractions }))
299 }
300 "regexp" => {
301 self.next();
302 Ok(PipelineStage::Regexp(
303 self.expect_string("a regexp pattern")?,
304 ))
305 }
306 "pattern" => {
307 self.next();
308 Ok(PipelineStage::Pattern(
309 self.expect_string("a pattern string")?,
310 ))
311 }
312 "unpack" => {
313 self.next();
314 Ok(PipelineStage::Unpack)
315 }
316 "decolorize" => {
317 self.next();
318 Ok(PipelineStage::Decolorize)
319 }
320 "distinct" => {
321 self.next();
322 Ok(PipelineStage::Distinct(self.parse_label_name_list()?))
323 }
324 "line_format" => {
325 self.next();
326 Ok(PipelineStage::LineFormat(
327 self.expect_string("a line_format template")?,
328 ))
329 }
330 "label_format" => {
331 self.next();
332 Ok(PipelineStage::LabelFormat(self.parse_label_formats()?))
333 }
334 "drop" => {
335 self.next();
336 Ok(PipelineStage::Drop(self.parse_label_predicate_list()?))
337 }
338 "keep" => {
339 self.next();
340 Ok(PipelineStage::Keep(self.parse_label_predicate_list()?))
341 }
342 _ => Ok(PipelineStage::LabelFilter(self.parse_label_filter_expr()?)),
345 }
346 }
347
348 fn expect_string(&mut self, what: &str) -> Result<String, ParseError> {
349 match self.next() {
350 Some(t) => match t.token {
351 Token::String(value) => Ok(value),
352 ref other => {
353 Err(self.error_at(format!("expected {what}, found '{other}'"), Some(&t)))
354 }
355 },
356 None => Err(self.error_at(format!("expected {what}, found end of input"), None)),
357 }
358 }
359
360 fn expect_ident(&mut self, what: &str) -> Result<String, ParseError> {
362 match self.next() {
363 Some(t) => match &t.token {
364 Token::Ident(name) => Ok(name.clone()),
365 other if let Some(kw) = Token::keyword_text(other) => Ok(kw.to_string()),
366 other => Err(self.error_at(format!("expected {what}, found '{other}'"), Some(&t))),
367 },
368 None => Err(self.error_at(format!("expected {what}, found end of input"), None)),
369 }
370 }
371
372 fn parse_label_extractions(&mut self) -> Result<Vec<LabelExtraction>, ParseError> {
375 let mut out = Vec::new();
376 if !matches!(self.peek().map(|t| &t.token), Some(Token::Ident(_))) {
378 return Ok(out);
379 }
380 loop {
381 let name = self.expect_ident("a label name")?;
382 let expr = if matches!(self.peek().map(|t| &t.token), Some(Token::Eq)) {
383 self.next();
384 Some(self.expect_string("an extraction expression")?)
385 } else {
386 None
387 };
388 out.push(LabelExtraction { name, expr });
389 if !self.eat_comma() {
390 break;
391 }
392 }
393 Ok(out)
394 }
395
396 fn parse_label_formats(&mut self) -> Result<Vec<LabelFormat>, ParseError> {
399 let mut out = Vec::new();
400 loop {
401 let dst = self.expect_ident("a destination label")?;
402 self.expect(&Token::Eq, "'=' in label_format assignment")?;
403 let value = match self.next() {
404 Some(t) => match t.token {
405 Token::String(tmpl) => LabelFormatValue::Template(tmpl),
406 Token::Ident(src) => LabelFormatValue::Rename(src),
407 ref other => {
408 return Err(self.error_at(
409 format!("expected a source label or template string, found '{other}'"),
410 Some(&t),
411 ));
412 }
413 },
414 None => {
415 return Err(self.error_at("expected a source label or template string", None));
416 }
417 };
418 out.push(LabelFormat { dst, value });
419 if !self.eat_comma() {
420 break;
421 }
422 }
423 Ok(out)
424 }
425
426 fn parse_label_name_list(&mut self) -> Result<Vec<String>, ParseError> {
428 let mut out = vec![self.expect_ident("a label name")?];
429 while self.eat_comma() {
430 out.push(self.expect_ident("a label name")?);
431 }
432 Ok(out)
433 }
434
435 fn parse_flags(&mut self) -> Vec<String> {
437 let mut flags = Vec::new();
438 while let Some(Token::Flag(name)) = self.peek().map(|t| &t.token) {
439 flags.push(name.clone());
440 self.next();
441 }
442 flags
443 }
444
445 fn parse_label_predicate_list(&mut self) -> Result<Vec<LabelPredicate>, ParseError> {
448 let mut out = vec![self.parse_label_predicate()?];
449 while self.eat_comma() {
450 out.push(self.parse_label_predicate()?);
451 }
452 Ok(out)
453 }
454
455 fn parse_label_predicate(&mut self) -> Result<LabelPredicate, ParseError> {
456 let name = self.expect_ident("a label name")?;
457 let matcher = match self.peek().map(|t| &t.token) {
458 Some(Token::Eq | Token::Neq | Token::Re | Token::Nre) => {
459 let tok = self.next().expect("peeked");
460 let op = token_to_match_op(&tok.token).expect("peeked matcher token");
461 let value = self.expect_string("a quoted matcher value")?;
462 Some((op, value))
463 }
464 _ => None,
465 };
466 Ok(LabelPredicate { name, matcher })
467 }
468
469 fn parse_unwrap(&mut self) -> Result<Unwrap, ParseError> {
471 let first = self.expect_ident("a label to unwrap")?;
472 if matches!(self.peek().map(|t| &t.token), Some(Token::LParen)) {
473 self.next();
474 let label = self.expect_ident("a label inside the conversion")?;
475 self.expect(&Token::RParen, "')' to close the unwrap conversion")?;
476 Ok(Unwrap {
477 label,
478 conversion: Some(first),
479 })
480 } else {
481 Ok(Unwrap {
482 label: first,
483 conversion: None,
484 })
485 }
486 }
487
488 fn parse_label_filter_expr(&mut self) -> Result<LabelFilterExpr, ParseError> {
490 let mut left = self.parse_label_filter_and()?;
491 while matches!(self.peek().map(|t| &t.token), Some(Token::Or)) {
492 self.next();
493 let right = self.parse_label_filter_and()?;
494 left = LabelFilterExpr::Or(Box::new(left), Box::new(right));
495 }
496 Ok(left)
497 }
498
499 fn parse_label_filter_and(&mut self) -> Result<LabelFilterExpr, ParseError> {
500 let mut left = self.parse_label_filter_primary()?;
501 while matches!(
503 self.peek().map(|t| &t.token),
504 Some(Token::And) | Some(Token::Comma)
505 ) {
506 self.next();
507 let right = self.parse_label_filter_primary()?;
508 left = LabelFilterExpr::And(Box::new(left), Box::new(right));
509 }
510 Ok(left)
511 }
512
513 fn parse_label_filter_primary(&mut self) -> Result<LabelFilterExpr, ParseError> {
515 if matches!(self.peek().map(|t| &t.token), Some(Token::LParen)) {
516 self.next();
517 let expr = self.parse_label_filter_expr()?;
518 self.expect(&Token::RParen, "')' to close a label filter group")?;
519 return Ok(expr);
520 }
521 self.parse_label_filter_pred()
522 }
523
524 fn parse_label_filter_pred(&mut self) -> Result<LabelFilterExpr, ParseError> {
525 let name = self.expect_ident("a label name")?;
526 let (op_token, op) = match self.next() {
527 Some(t) => {
528 let op = match t.token {
529 Token::Eq => FilterOp::Eq,
530 Token::Neq => FilterOp::Neq,
531 Token::Re => FilterOp::Re,
532 Token::Nre => FilterOp::Nre,
533 Token::CmpEq => FilterOp::CmpEq,
534 Token::Gt => FilterOp::Gt,
535 Token::Gte => FilterOp::Gte,
536 Token::Lt => FilterOp::Lt,
537 Token::Lte => FilterOp::Lte,
538 ref other => {
539 return Err(self.error_at(
540 format!(
541 "expected a comparison operator in label filter, found '{other}'"
542 ),
543 Some(&t),
544 ));
545 }
546 };
547 (t, op)
548 }
549 None => {
550 return Err(self.error_at("expected a comparison operator in label filter", None));
551 }
552 };
553
554 let value = self.parse_filter_value()?;
555 self.check_op_value(op, &value, &op_token)?;
556 Ok(LabelFilterExpr::Pred(LabelFilterPred { name, op, value }))
557 }
558
559 fn parse_filter_value(&mut self) -> Result<FilterValue, ParseError> {
560 if self.eat_ip_ident() {
562 return Ok(FilterValue::Ip(self.parse_ip_call()?));
563 }
564 match self.next() {
565 Some(t) => match t.token {
566 Token::String(s) => Ok(FilterValue::String(s)),
567 Token::Number(n) => Ok(FilterValue::Number(n)),
568 Token::Duration(d) => Ok(FilterValue::Duration(d)),
569 Token::Bytes(b) => Ok(FilterValue::Bytes(b)),
570 ref other => Err(self.error_at(
571 format!(
572 "expected a string, number, duration, bytes, or ip() in label filter, found '{other}'"
573 ),
574 Some(&t),
575 )),
576 },
577 None => Err(self.error_at("expected a value in label filter", None)),
578 }
579 }
580
581 fn check_op_value(
585 &self,
586 op: FilterOp,
587 value: &FilterValue,
588 op_token: &SpannedToken,
589 ) -> Result<(), ParseError> {
590 let ok = match op {
591 FilterOp::Re | FilterOp::Nre => {
592 matches!(value, FilterValue::String(_) | FilterValue::Ip(_))
593 }
594 FilterOp::Gt | FilterOp::Gte | FilterOp::Lt | FilterOp::Lte => {
595 matches!(
596 value,
597 FilterValue::Number(_) | FilterValue::Duration(_) | FilterValue::Bytes(_)
598 )
599 }
600 FilterOp::Eq | FilterOp::Neq | FilterOp::CmpEq => true,
601 };
602 if ok {
603 Ok(())
604 } else {
605 Err(self.error_at(
606 format!(
607 "operator '{}' is not valid for this value type",
608 op_token.token
609 ),
610 Some(op_token),
611 ))
612 }
613 }
614
615 pub(crate) fn parse_selector(&mut self) -> Result<StreamSelector, ParseError> {
617 self.expect(&Token::LBrace, "'{' to start a stream selector")?;
618
619 let mut matchers = Vec::new();
620 loop {
621 match self.peek() {
622 Some(t) if t.token == Token::RBrace => {
623 self.next();
624 break;
625 }
626 Some(_) => {
627 matchers.push(self.parse_matcher()?);
628 match self.next() {
629 Some(t) if t.token == Token::Comma => continue,
630 Some(t) if t.token == Token::RBrace => break,
631 Some(t) => {
632 return Err(self.error_at(
633 format!(
634 "expected ',' or '}}' in stream selector, found '{}'",
635 t.token
636 ),
637 Some(&t),
638 ));
639 }
640 None => {
641 return Err(
642 self.error_at("unclosed stream selector (missing '}')", None)
643 );
644 }
645 }
646 }
647 None => {
648 return Err(self.error_at("unclosed stream selector (missing '}')", None));
649 }
650 }
651 }
652
653 Ok(StreamSelector { matchers })
654 }
655
656 fn parse_matcher(&mut self) -> Result<LabelMatcher, ParseError> {
658 let name = self.expect_ident("label name")?;
661
662 let op = match self.next() {
663 Some(t) => match token_to_match_op(&t.token) {
664 Some(op) => op,
665 None => {
666 return Err(self.error_at(
667 format!(
668 "expected matcher operator (=, !=, =~, !~), found '{}'",
669 t.token
670 ),
671 Some(&t),
672 ));
673 }
674 },
675 None => {
676 return Err(self.error_at("expected matcher operator, found end of input", None));
677 }
678 };
679
680 let value = match self.next() {
681 Some(t) => match t.token {
682 Token::String(value) => value,
683 ref other => {
684 return Err(self.error_at(
685 format!("expected quoted label value, found '{other}'"),
686 Some(&t),
687 ));
688 }
689 },
690 None => return Err(self.error_at("expected label value, found end of input", None)),
691 };
692
693 Ok(LabelMatcher { name, op, value })
694 }
695
696 fn parse_metric_expr(&mut self) -> Result<MetricQuery, ParseError> {
700 self.parse_binary(0)
701 }
702
703 fn parse_binary(&mut self, min_prec: u8) -> Result<MetricQuery, ParseError> {
710 let mut left = self.parse_metric_unary()?;
711 while let Some((op, prec, right_assoc)) = self.peek_binary_op() {
712 if prec < min_prec {
713 break;
714 }
715 self.next(); let bool_modifier = if is_comparison(op)
719 && matches!(self.peek().map(|t| &t.token), Some(Token::Bool))
720 {
721 self.next();
722 true
723 } else {
724 false
725 };
726
727 let matching = self.parse_optional_vector_match()?;
729
730 let next_min = if right_assoc { prec } else { prec + 1 };
731 let right = self.parse_binary(next_min)?;
732 left = MetricQuery::Binary(Box::new(BinaryExpr {
733 op,
734 left,
735 right,
736 bool_modifier,
737 matching,
738 }));
739 }
740 Ok(left)
741 }
742
743 fn parse_optional_vector_match(&mut self) -> Result<Option<VectorMatch>, ParseError> {
747 let on = match self.peek().map(|t| &t.token) {
748 Some(Token::On) => true,
749 Some(Token::Ignoring) => false,
750 _ => return Ok(None),
751 };
752 self.next();
753 let labels = self.parse_label_paren_list("on/ignoring")?;
754
755 let grouped = match self.peek().map(|t| &t.token) {
758 Some(Token::GroupLeft | Token::GroupRight) => {
759 self.next();
760 if matches!(self.peek().map(|t| &t.token), Some(Token::LParen)) {
761 self.parse_label_paren_list("group_left/group_right")?;
762 }
763 true
764 }
765 _ => false,
766 };
767
768 Ok(Some(VectorMatch {
769 on,
770 labels,
771 grouped,
772 }))
773 }
774
775 fn parse_label_paren_list(&mut self, what: &str) -> Result<Vec<String>, ParseError> {
777 self.expect(&Token::LParen, "'(' after label-list clause")?;
778 let mut labels = Vec::new();
779 if !matches!(self.peek().map(|t| &t.token), Some(Token::RParen)) {
780 loop {
781 labels.push(self.expect_ident(what)?);
782 if !self.eat_comma() {
783 break;
784 }
785 }
786 }
787 self.expect(&Token::RParen, "')' to close label list")?;
788 Ok(labels)
789 }
790
791 fn peek_binary_op(&self) -> Option<(BinOp, u8, bool)> {
793 let op = match self.peek().map(|t| &t.token)? {
794 Token::Or => (BinOp::Or, 1, false),
795 Token::And => (BinOp::And, 2, false),
796 Token::Unless => (BinOp::Unless, 2, false),
797 Token::CmpEq => (BinOp::Eq, 3, false),
798 Token::Neq => (BinOp::Neq, 3, false),
799 Token::Gt => (BinOp::Gt, 3, false),
800 Token::Gte => (BinOp::Gte, 3, false),
801 Token::Lt => (BinOp::Lt, 3, false),
802 Token::Lte => (BinOp::Lte, 3, false),
803 Token::Add => (BinOp::Add, 4, false),
804 Token::Sub => (BinOp::Sub, 4, false),
805 Token::Mul => (BinOp::Mul, 5, false),
806 Token::Div => (BinOp::Div, 5, false),
807 Token::Mod => (BinOp::Mod, 5, false),
808 Token::Pow => (BinOp::Pow, 6, true),
809 _ => return None,
810 };
811 Some(op)
812 }
813
814 fn parse_metric_unary(&mut self) -> Result<MetricQuery, ParseError> {
816 if matches!(self.peek().map(|t| &t.token), Some(Token::Sub)) {
817 self.next();
818 let inner = self.parse_metric_unary()?;
819 return Ok(MetricQuery::Binary(Box::new(BinaryExpr {
821 op: BinOp::Sub,
822 left: MetricQuery::Literal(0.0),
823 right: inner,
824 bool_modifier: false,
825 matching: None,
826 })));
827 }
828 if matches!(self.peek().map(|t| &t.token), Some(Token::Add)) {
829 self.next();
830 return self.parse_metric_unary();
831 }
832 self.parse_metric_atom()
833 }
834
835 fn parse_metric_atom(&mut self) -> Result<MetricQuery, ParseError> {
838 match self.peek().map(|t| &t.token) {
839 Some(Token::LParen) => {
840 self.next();
841 let inner = self.parse_metric_expr()?;
842 self.expect(&Token::RParen, "')' to close a parenthesized expression")?;
843 Ok(inner)
844 }
845 Some(Token::Number(n)) => {
846 let n = *n;
847 self.next();
848 Ok(MetricQuery::Literal(n))
849 }
850 Some(Token::Ident(name)) => {
851 let name = name.clone();
852 if RangeFunction::from_name(&name).is_some() {
853 self.parse_range_aggregation()
854 } else if AggregationFunction::from_name(&name).is_some() {
855 self.parse_vector_aggregation()
856 } else if name == "vector" {
857 self.parse_vector_literal()
858 } else if name == "label_replace" {
859 self.parse_label_replace()
860 } else {
861 let t = self.peek().cloned();
862 Err(self.error_at(format!("unknown metric function '{name}'"), t.as_ref()))
863 }
864 }
865 _ => {
866 let t = self.peek().cloned();
867 Err(self.error_at("expected a metric query", t.as_ref()))
868 }
869 }
870 }
871
872 fn parse_range_aggregation(&mut self) -> Result<MetricQuery, ParseError> {
876 let name = self.expect_ident("a range function")?;
877 let function = RangeFunction::from_name(&name).expect("checked by caller");
878 self.expect(&Token::LParen, "'(' after a range function")?;
879
880 let param =
881 self.parse_optional_scalar_param(function.takes_param(), "the range function")?;
882
883 let (log_query, range, mut offset, unwrap) = self.parse_log_range_expr()?;
884 self.expect(&Token::RParen, "')' to close the range aggregation")?;
885
886 if offset.is_none() {
888 offset = self.parse_optional_offset()?;
889 }
890
891 let grouping = self.parse_optional_grouping()?;
893
894 Ok(MetricQuery::Range(Box::new(RangeAggregation {
895 function,
896 log_query,
897 range,
898 offset,
899 unwrap,
900 param,
901 grouping,
902 })))
903 }
904
905 fn parse_vector_literal(&mut self) -> Result<MetricQuery, ParseError> {
907 self.expect_ident("vector")?;
908 self.expect(&Token::LParen, "'(' after vector")?;
909 let value = self.parse_number("a scalar value")?;
910 self.expect(&Token::RParen, "')' to close vector(...)")?;
911 Ok(MetricQuery::VectorLiteral(value))
912 }
913
914 fn parse_label_replace(&mut self) -> Result<MetricQuery, ParseError> {
916 self.expect_ident("label_replace")?;
917 self.expect(&Token::LParen, "'(' after label_replace")?;
918 let inner = self.parse_metric_expr()?;
919 self.expect(&Token::Comma, "',' after the label_replace vector")?;
920 let dst_label = self.expect_string("the destination label")?;
921 self.expect(&Token::Comma, "',' after the destination label")?;
922 let replacement = self.expect_string("the replacement template")?;
923 self.expect(&Token::Comma, "',' after the replacement")?;
924 let src_label = self.expect_string("the source label")?;
925 self.expect(&Token::Comma, "',' after the source label")?;
926 let regex = self.expect_string("the regex")?;
927 self.expect(&Token::RParen, "')' to close label_replace(...)")?;
928 Ok(MetricQuery::LabelReplace(Box::new(
929 crate::metric::LabelReplace {
930 inner,
931 dst_label,
932 replacement,
933 src_label,
934 regex,
935 },
936 )))
937 }
938
939 fn parse_log_range_expr(
943 &mut self,
944 ) -> Result<
945 (
946 LogQuery,
947 std::time::Duration,
948 Option<std::time::Duration>,
949 Option<Unwrap>,
950 ),
951 ParseError,
952 > {
953 let paren = matches!(self.peek().map(|t| &t.token), Some(Token::LParen));
956 if paren {
957 self.next();
958 }
959 let selector = self.parse_selector()?;
960 let mut pipeline = self.parse_pipeline()?;
961 if paren {
962 self.expect(
963 &Token::RParen,
964 "')' to close the parenthesized log expression",
965 )?;
966 }
967
968 let range = self.parse_range_window()?;
970 let offset = self.parse_optional_offset()?;
971
972 let unwrap = match pipeline.last() {
975 Some(PipelineStage::Unwrap(_)) => {
976 let Some(PipelineStage::Unwrap(u)) = pipeline.pop() else {
977 unreachable!()
978 };
979 Some(u)
980 }
981 _ => None,
982 };
983
984 Ok((
985 LogQuery {
986 selector: selector.clone(),
987 pipeline,
988 },
989 range,
990 offset,
991 unwrap,
992 ))
993 }
994
995 fn parse_range_window(&mut self) -> Result<std::time::Duration, ParseError> {
997 self.expect(&Token::LBracket, "'[' to start a range window")?;
998 let range = match self.next() {
999 Some(t) => match t.token {
1000 Token::Duration(d) => d,
1001 ref other => {
1002 return Err(self.error_at(
1003 format!("expected a range duration, found '{other}'"),
1004 Some(&t),
1005 ));
1006 }
1007 },
1008 None => return Err(self.error_at("expected a range duration", None)),
1009 };
1010 self.expect(&Token::RBracket, "']' to close a range window")?;
1011 Ok(range)
1012 }
1013
1014 fn parse_optional_offset(&mut self) -> Result<Option<std::time::Duration>, ParseError> {
1016 if !matches!(self.peek().map(|t| &t.token), Some(Token::Offset)) {
1017 return Ok(None);
1018 }
1019 self.next();
1020 match self.next() {
1021 Some(t) => match t.token {
1022 Token::Duration(d) => Ok(Some(d)),
1023 ref other => Err(self.error_at(
1024 format!("expected a duration after 'offset', found '{other}'"),
1025 Some(&t),
1026 )),
1027 },
1028 None => Err(self.error_at("expected a duration after 'offset'", None)),
1029 }
1030 }
1031
1032 fn parse_vector_aggregation(&mut self) -> Result<MetricQuery, ParseError> {
1035 let name = self.expect_ident("an aggregation function")?;
1036 let function = AggregationFunction::from_name(&name).expect("checked by caller");
1037
1038 let mut grouping = self.parse_optional_grouping()?;
1040
1041 self.expect(&Token::LParen, "'(' after an aggregation function")?;
1042 let param = self.parse_optional_scalar_param(function.takes_param(), "the aggregation")?;
1043 let inner = self.parse_metric_expr()?;
1044 self.expect(&Token::RParen, "')' to close the aggregation")?;
1045
1046 if grouping.is_none() {
1048 grouping = self.parse_optional_grouping()?;
1049 }
1050
1051 Ok(MetricQuery::Vector(Box::new(VectorAggregation {
1052 function,
1053 param,
1054 grouping,
1055 inner,
1056 })))
1057 }
1058
1059 fn parse_optional_grouping(&mut self) -> Result<Option<Grouping>, ParseError> {
1061 let without = match self.peek().map(|t| &t.token) {
1062 Some(Token::By) => false,
1063 Some(Token::Without) => true,
1064 _ => return Ok(None),
1065 };
1066 self.next();
1067 let labels = self.parse_label_paren_list("a grouping label")?;
1068 Ok(Some(Grouping { without, labels }))
1069 }
1070
1071 fn parse_number(&mut self, what: &str) -> Result<f64, ParseError> {
1073 match self.next() {
1074 Some(t) => match t.token {
1075 Token::Number(n) => Ok(n),
1076 ref other => {
1077 Err(self.error_at(format!("expected {what}, found '{other}'"), Some(&t)))
1078 }
1079 },
1080 None => Err(self.error_at(format!("expected {what}, found end of input"), None)),
1081 }
1082 }
1083
1084 fn parse_optional_scalar_param(
1087 &mut self,
1088 takes_param: bool,
1089 what: &str,
1090 ) -> Result<Option<f64>, ParseError> {
1091 if !takes_param {
1092 return Ok(None);
1093 }
1094 let p = self.parse_number("a scalar parameter")?;
1095 self.expect(&Token::Comma, &format!("',' after {what} parameter"))?;
1096 Ok(Some(p))
1097 }
1098}
1099
1100fn token_to_match_op(token: &Token) -> Option<MatchOp> {
1103 match token {
1104 Token::Eq => Some(MatchOp::Eq),
1105 Token::Neq => Some(MatchOp::Neq),
1106 Token::Re => Some(MatchOp::Re),
1107 Token::Nre => Some(MatchOp::Nre),
1108 _ => None,
1109 }
1110}
1111
1112fn is_comparison(op: BinOp) -> bool {
1114 matches!(
1115 op,
1116 BinOp::Eq | BinOp::Neq | BinOp::Gt | BinOp::Gte | BinOp::Lt | BinOp::Lte
1117 )
1118}
1119
1120#[cfg(test)]
1121mod tests {
1122 use super::*;
1123
1124 fn matcher(name: &str, op: MatchOp, value: &str) -> LabelMatcher {
1125 LabelMatcher {
1126 name: name.to_string(),
1127 op,
1128 value: value.to_string(),
1129 }
1130 }
1131
1132 #[test]
1133 fn parses_single_matcher() {
1134 assert_eq!(
1135 parse_selector(r#"{job="api"}"#).unwrap().matchers,
1136 vec![matcher("job", MatchOp::Eq, "api")]
1137 );
1138 }
1139
1140 #[test]
1141 fn parses_multiple_matchers_with_all_operators() {
1142 assert_eq!(
1143 parse_selector(
1144 r#"{service_name="frontend", level!="debug", namespace=~"prod-.*", env!~"dev.*"}"#
1145 )
1146 .unwrap()
1147 .matchers,
1148 vec![
1149 matcher("service_name", MatchOp::Eq, "frontend"),
1150 matcher("level", MatchOp::Neq, "debug"),
1151 matcher("namespace", MatchOp::Re, "prod-.*"),
1152 matcher("env", MatchOp::Nre, "dev.*"),
1153 ]
1154 );
1155 }
1156
1157 #[test]
1158 fn parses_empty_selector_and_trailing_comma() {
1159 assert!(parse_selector("{}").unwrap().matchers.is_empty());
1160 assert_eq!(parse_selector(r#"{job="api",}"#).unwrap().matchers.len(), 1);
1161 }
1162
1163 #[test]
1164 fn keywords_are_valid_label_names() {
1165 assert_eq!(
1166 parse_selector(r#"{by="x", offset!="y"}"#).unwrap().matchers,
1167 vec![
1168 matcher("by", MatchOp::Eq, "x"),
1169 matcher("offset", MatchOp::Neq, "y"),
1170 ]
1171 );
1172 }
1173
1174 #[test]
1175 fn parse_query_returns_empty_pipeline() {
1176 let query = parse_query(r#"{job="api"}"#).unwrap();
1177 assert_eq!(query.selector.matchers.len(), 1);
1178 assert!(query.pipeline.is_empty());
1179 }
1180
1181 #[test]
1182 fn parse_query_parses_a_line_filter_pipeline() {
1183 let query = parse_query(r#"{job="api"} |= "error""#).unwrap();
1184 assert_eq!(query.selector.matchers.len(), 1);
1185 assert_eq!(
1186 query.pipeline,
1187 vec![PipelineStage::LineFilter(LineFilter {
1188 op: LineFilterOp::Contains,
1189 value: "error".to_string(),
1190 is_ip: false,
1191 })]
1192 );
1193 }
1194
1195 #[test]
1196 fn rejects_missing_brace() {
1197 let err = parse_selector(r#"{job="api""#).unwrap_err();
1198 assert!(err.message.contains("missing '}'"), "{err}");
1199 }
1200
1201 #[test]
1202 fn rejects_missing_operator_and_value() {
1203 let err = parse_selector(r#"{job}"#).unwrap_err();
1204 assert!(err.message.contains("matcher operator"), "{err}");
1205
1206 let err = parse_selector(r#"{job=}"#).unwrap_err();
1207 assert!(err.message.contains("quoted label value"), "{err}");
1208
1209 let err = parse_selector(r#"{job=api}"#).unwrap_err();
1210 assert!(err.message.contains("quoted label value"), "{err}");
1211 }
1212
1213 #[test]
1214 fn rejects_missing_selector() {
1215 let err = parse_selector(r#"job="api""#).unwrap_err();
1216 assert!(err.message.contains("'{'"), "{err}");
1217 }
1218
1219 #[test]
1220 fn error_positions_point_at_offending_token() {
1221 let err = parse_selector("{job =\n 5}").unwrap_err();
1222 assert_eq!((err.line, err.col), (2, 3));
1223 }
1224
1225 #[test]
1226 fn lex_errors_propagate_with_position() {
1227 let err = parse_selector(r#"{job="unterminated}"#).unwrap_err();
1228 assert!(err.message.contains("unterminated"), "{err}");
1229 }
1230
1231 fn pipeline(input: &str) -> Vec<PipelineStage> {
1234 parse_query(input).expect("parse").pipeline
1235 }
1236
1237 fn line(op: LineFilterOp, value: &str) -> PipelineStage {
1238 PipelineStage::LineFilter(LineFilter {
1239 op,
1240 value: value.to_string(),
1241 is_ip: false,
1242 })
1243 }
1244
1245 #[test]
1246 fn parses_all_line_filter_operators() {
1247 assert_eq!(
1248 pipeline(r#"{a="b"} |= "keep" != "drop" |~ "re" !~ "nre""#),
1249 vec![
1250 line(LineFilterOp::Contains, "keep"),
1251 line(LineFilterOp::NotContains, "drop"),
1252 line(LineFilterOp::Regex, "re"),
1253 line(LineFilterOp::NotRegex, "nre"),
1254 ]
1255 );
1256 }
1257
1258 #[test]
1259 fn parses_json_and_logfmt_with_and_without_extractions() {
1260 assert_eq!(
1261 pipeline(r#"{a="b"} | json"#),
1262 vec![PipelineStage::Json(vec![])]
1263 );
1264 assert_eq!(
1265 pipeline(r#"{a="b"} | json status="response.status", method"#),
1266 vec![PipelineStage::Json(vec![
1267 LabelExtraction {
1268 name: "status".into(),
1269 expr: Some("response.status".into()),
1270 },
1271 LabelExtraction {
1272 name: "method".into(),
1273 expr: None,
1274 },
1275 ])]
1276 );
1277 assert_eq!(
1278 pipeline(r#"{a="b"} | logfmt"#),
1279 vec![PipelineStage::Logfmt(LogfmtStage::default())]
1280 );
1281 }
1282
1283 #[test]
1284 fn parses_logfmt_flags() {
1285 assert_eq!(
1286 pipeline(r#"{a="b"} | logfmt --strict --keep-empty host"#),
1287 vec![PipelineStage::Logfmt(LogfmtStage {
1288 flags: vec!["strict".into(), "keep-empty".into()],
1289 extractions: vec![LabelExtraction {
1290 name: "host".into(),
1291 expr: None,
1292 }],
1293 })]
1294 );
1295 }
1296
1297 #[test]
1298 fn parses_decolorize_and_distinct() {
1299 assert_eq!(
1300 pipeline(r#"{a="b"} | decolorize"#),
1301 vec![PipelineStage::Decolorize]
1302 );
1303 assert_eq!(
1304 pipeline(r#"{a="b"} | distinct host, path"#),
1305 vec![PipelineStage::Distinct(vec!["host".into(), "path".into()])]
1306 );
1307 }
1308
1309 #[test]
1310 fn parses_ip_line_and_label_filters() {
1311 assert_eq!(
1312 pipeline(r#"{a="b"} |= ip("192.168.4.5/16")"#),
1313 vec![PipelineStage::LineFilter(LineFilter {
1314 op: LineFilterOp::Contains,
1315 value: "192.168.4.5/16".into(),
1316 is_ip: true,
1317 })]
1318 );
1319 assert_eq!(
1320 pipeline(r#"{a="b"} | logfmt | addr = ip("10.0.0.0/8")"#),
1321 vec![
1322 PipelineStage::Logfmt(LogfmtStage::default()),
1323 PipelineStage::LabelFilter(LabelFilterExpr::Pred(LabelFilterPred {
1324 name: "addr".into(),
1325 op: FilterOp::Eq,
1326 value: FilterValue::Ip("10.0.0.0/8".into()),
1327 })),
1328 ]
1329 );
1330 }
1331
1332 #[test]
1333 fn parses_bytes_label_filter() {
1334 assert_eq!(
1335 pipeline(r#"{a="b"} | logfmt | size > 20KB"#),
1336 vec![
1337 PipelineStage::Logfmt(LogfmtStage::default()),
1338 PipelineStage::LabelFilter(LabelFilterExpr::Pred(LabelFilterPred {
1339 name: "size".into(),
1340 op: FilterOp::Gt,
1341 value: FilterValue::Bytes(20_000),
1342 })),
1343 ]
1344 );
1345 }
1346
1347 #[test]
1348 fn parses_parenthesized_label_filter() {
1349 let stages = pipeline(r#"{x="y"} | (a="1" or b="2") and c="3""#);
1351 let PipelineStage::LabelFilter(LabelFilterExpr::And(left, right)) = &stages[0] else {
1352 panic!("expected top-level And, got {:?}", stages[0]);
1353 };
1354 assert!(matches!(**left, LabelFilterExpr::Or(_, _)));
1355 assert!(matches!(**right, LabelFilterExpr::Pred(_)));
1356 }
1357
1358 #[test]
1359 fn parses_drop_keep_with_matchers() {
1360 assert_eq!(
1361 pipeline(r#"{a="b"} | json | drop __error__, method="GET""#),
1362 vec![
1363 PipelineStage::Json(vec![]),
1364 PipelineStage::Drop(vec![
1365 LabelPredicate {
1366 name: "__error__".into(),
1367 matcher: None,
1368 },
1369 LabelPredicate {
1370 name: "method".into(),
1371 matcher: Some((MatchOp::Eq, "GET".into())),
1372 },
1373 ]),
1374 ]
1375 );
1376 }
1377
1378 #[test]
1379 fn parses_regexp_pattern_unpack() {
1380 assert_eq!(
1381 pipeline(r#"{a="b"} | regexp "(?P<method>\\w+)""#),
1382 vec![PipelineStage::Regexp(r"(?P<method>\w+)".into())]
1383 );
1384 assert_eq!(
1385 pipeline(r#"{a="b"} | pattern "<method> <path>""#),
1386 vec![PipelineStage::Pattern("<method> <path>".into())]
1387 );
1388 assert_eq!(pipeline(r#"{a="b"} | unpack"#), vec![PipelineStage::Unpack]);
1389 }
1390
1391 #[test]
1392 fn parses_formatters() {
1393 assert_eq!(
1394 pipeline(r#"{a="b"} | line_format "{{.msg}}""#),
1395 vec![PipelineStage::LineFormat("{{.msg}}".into())]
1396 );
1397 assert_eq!(
1398 pipeline(r#"{a="b"} | label_format dst="{{.src}}", renamed=original"#),
1399 vec![PipelineStage::LabelFormat(vec![
1400 LabelFormat {
1401 dst: "dst".into(),
1402 value: LabelFormatValue::Template("{{.src}}".into()),
1403 },
1404 LabelFormat {
1405 dst: "renamed".into(),
1406 value: LabelFormatValue::Rename("original".into()),
1407 },
1408 ])]
1409 );
1410 }
1411
1412 #[test]
1413 fn parses_drop_and_keep() {
1414 let bare = |name: &str| LabelPredicate {
1415 name: name.to_string(),
1416 matcher: None,
1417 };
1418 assert_eq!(
1419 pipeline(r#"{a="b"} | drop level, source"#),
1420 vec![PipelineStage::Drop(vec![bare("level"), bare("source")])]
1421 );
1422 assert_eq!(
1423 pipeline(r#"{a="b"} | keep pod"#),
1424 vec![PipelineStage::Keep(vec![bare("pod")])]
1425 );
1426 }
1427
1428 #[test]
1429 fn parses_unwrap_forms() {
1430 assert_eq!(
1431 pipeline(r#"{a="b"} | unwrap duration_ms"#),
1432 vec![PipelineStage::Unwrap(Unwrap {
1433 label: "duration_ms".into(),
1434 conversion: None,
1435 })]
1436 );
1437 assert_eq!(
1438 pipeline(r#"{a="b"} | unwrap duration(latency)"#),
1439 vec![PipelineStage::Unwrap(Unwrap {
1440 label: "latency".into(),
1441 conversion: Some("duration".into()),
1442 })]
1443 );
1444 }
1445
1446 #[test]
1447 fn parses_label_filter_string_and_numeric() {
1448 assert_eq!(
1449 pipeline(r#"{a="b"} | level="error""#),
1450 vec![PipelineStage::LabelFilter(LabelFilterExpr::Pred(
1451 LabelFilterPred {
1452 name: "level".into(),
1453 op: FilterOp::Eq,
1454 value: FilterValue::String("error".into()),
1455 }
1456 ))]
1457 );
1458 assert_eq!(
1459 pipeline(r#"{a="b"} | status >= 500"#),
1460 vec![PipelineStage::LabelFilter(LabelFilterExpr::Pred(
1461 LabelFilterPred {
1462 name: "status".into(),
1463 op: FilterOp::Gte,
1464 value: FilterValue::Number(500.0),
1465 }
1466 ))]
1467 );
1468 }
1469
1470 #[test]
1471 fn label_filter_and_or_precedence() {
1472 let stages = pipeline(r#"{x="y"} | a="1" and b="2" or c="3""#);
1474 let PipelineStage::LabelFilter(expr) = &stages[0] else {
1475 panic!("expected label filter");
1476 };
1477 match expr {
1478 LabelFilterExpr::Or(left, right) => {
1479 assert!(matches!(**left, LabelFilterExpr::And(_, _)));
1480 assert!(matches!(**right, LabelFilterExpr::Pred(_)));
1481 }
1482 other => panic!("expected top-level Or, got {other:?}"),
1483 }
1484 }
1485
1486 #[test]
1487 fn label_filter_comma_is_conjunction() {
1488 let stages = pipeline(r#"{x="y"} | a="1", b="2""#);
1489 let PipelineStage::LabelFilter(expr) = &stages[0] else {
1490 panic!("expected label filter");
1491 };
1492 assert!(matches!(expr, LabelFilterExpr::And(_, _)));
1493 }
1494
1495 #[test]
1496 fn parses_full_pipeline_end_to_end() {
1497 let query = parse_query(
1498 r#"{app="api"} |= "error" | json | status >= 500 | line_format "{{.msg}}""#,
1499 )
1500 .unwrap();
1501 assert_eq!(query.pipeline.len(), 4);
1502 assert!(matches!(query.pipeline[0], PipelineStage::LineFilter(_)));
1503 assert!(matches!(query.pipeline[1], PipelineStage::Json(_)));
1504 assert!(matches!(query.pipeline[2], PipelineStage::LabelFilter(_)));
1505 assert!(matches!(query.pipeline[3], PipelineStage::LineFormat(_)));
1506 }
1507
1508 #[test]
1509 fn duration_label_filter() {
1510 assert_eq!(
1511 pipeline(r#"{a="b"} | logfmt | latency > 1s"#),
1512 vec![
1513 PipelineStage::Logfmt(LogfmtStage::default()),
1514 PipelineStage::LabelFilter(LabelFilterExpr::Pred(LabelFilterPred {
1515 name: "latency".into(),
1516 op: FilterOp::Gt,
1517 value: FilterValue::Duration(std::time::Duration::from_secs(1)),
1518 })),
1519 ]
1520 );
1521 }
1522
1523 #[test]
1524 fn rejects_regex_operator_against_number() {
1525 let err = parse_query(r#"{a="b"} | status =~ 500"#).unwrap_err();
1526 assert!(
1527 err.message.contains("not valid for this value type"),
1528 "{err}"
1529 );
1530 }
1531
1532 #[test]
1533 fn rejects_ordered_comparison_against_string() {
1534 let err = parse_query(r#"{a="b"} | level > "error""#).unwrap_err();
1535 assert!(
1536 err.message.contains("not valid for this value type"),
1537 "{err}"
1538 );
1539 }
1540
1541 #[test]
1542 fn rejects_line_filter_without_string() {
1543 let err = parse_query(r#"{a="b"} |= 5"#).unwrap_err();
1544 assert!(err.message.contains("quoted string"), "{err}");
1545 }
1546
1547 #[test]
1548 fn rejects_dangling_pipe() {
1549 let err = parse_query(r#"{a="b"} |"#).unwrap_err();
1550 assert!(err.message.contains("pipeline stage after '|'"), "{err}");
1551 }
1552
1553 use std::time::Duration;
1556
1557 fn metric(input: &str) -> MetricQuery {
1558 parse_metric_query(input).expect("parse metric")
1559 }
1560
1561 fn as_range(q: &MetricQuery) -> &RangeAggregation {
1562 match q {
1563 MetricQuery::Range(r) => r,
1564 other => panic!("expected range aggregation, got {other:?}"),
1565 }
1566 }
1567
1568 fn as_vector(q: &MetricQuery) -> &VectorAggregation {
1569 match q {
1570 MetricQuery::Vector(v) => v,
1571 other => panic!("expected vector aggregation, got {other:?}"),
1572 }
1573 }
1574
1575 fn as_binary(q: &MetricQuery) -> &BinaryExpr {
1576 match q {
1577 MetricQuery::Binary(b) => b,
1578 other => panic!("expected binary expression, got {other:?}"),
1579 }
1580 }
1581
1582 #[test]
1583 fn parses_on_and_ignoring_vector_matching() {
1584 let on = metric(r#"sum(rate({a="b"}[1m])) / on(service) sum(rate({a="c"}[1m]))"#);
1585 let m = as_binary(&on).matching.as_ref().expect("matching clause");
1586 assert!(m.on);
1587 assert_eq!(m.labels, vec!["service".to_string()]);
1588 assert!(!m.grouped);
1589
1590 let ign = metric(r#"sum(rate({a="b"}[1m])) / ignoring(level) sum(rate({a="c"}[1m]))"#);
1591 let m = as_binary(&ign).matching.as_ref().expect("matching clause");
1592 assert!(!m.on);
1593 assert_eq!(m.labels, vec!["level".to_string()]);
1594
1595 let grp =
1597 metric(r#"sum(rate({a="b"}[1m])) / on(service) group_left sum(rate({a="c"}[1m]))"#);
1598 assert!(as_binary(&grp).matching.as_ref().unwrap().grouped);
1599
1600 let plain = metric(r#"sum(rate({a="b"}[1m])) / sum(rate({a="c"}[1m]))"#);
1602 assert!(as_binary(&plain).matching.is_none());
1603 }
1604
1605 #[test]
1606 fn parses_bare_range_aggregation() {
1607 let q = metric(r#"rate({job="api"}[5m])"#);
1608 let r = as_range(&q);
1609 assert_eq!(r.function, RangeFunction::Rate);
1610 assert_eq!(r.range, Duration::from_secs(300));
1611 assert_eq!(r.log_query.selector.matchers.len(), 1);
1612 assert!(r.log_query.pipeline.is_empty());
1613 assert!(r.offset.is_none() && r.unwrap.is_none() && r.param.is_none());
1614 }
1615
1616 #[test]
1617 fn parses_range_aggregation_over_a_pipeline() {
1618 let q = metric(r#"count_over_time({job="api"} |= "error" [1h])"#);
1619 let r = as_range(&q);
1620 assert_eq!(r.function, RangeFunction::CountOverTime);
1621 assert_eq!(r.range, Duration::from_secs(3600));
1622 assert_eq!(r.log_query.pipeline.len(), 1);
1623 assert!(matches!(
1624 r.log_query.pipeline[0],
1625 PipelineStage::LineFilter(_)
1626 ));
1627 }
1628
1629 #[test]
1630 fn parses_every_range_function_name() {
1631 for (name, func) in [
1632 ("rate", RangeFunction::Rate),
1633 ("rate_counter", RangeFunction::RateCounter),
1634 ("count_over_time", RangeFunction::CountOverTime),
1635 ("bytes_rate", RangeFunction::BytesRate),
1636 ("bytes_over_time", RangeFunction::BytesOverTime),
1637 ("first_over_time", RangeFunction::FirstOverTime),
1638 ("last_over_time", RangeFunction::LastOverTime),
1639 ("absent_over_time", RangeFunction::AbsentOverTime),
1640 ] {
1641 let q = metric(&format!(r#"{name}({{a="b"}}[5m])"#));
1642 assert_eq!(as_range(&q).function, func, "{name}");
1643 }
1644 }
1645
1646 #[test]
1647 fn parses_offset_modifier() {
1648 let q = metric(r#"rate({a="b"}[5m] offset 1h)"#);
1649 let r = as_range(&q);
1650 assert_eq!(r.offset, Some(Duration::from_secs(3600)));
1651 }
1652
1653 #[test]
1654 fn parses_unwrap_range_aggregation() {
1655 let q = metric(r#"avg_over_time({job="api"} | json | unwrap duration [5m])"#);
1656 let r = as_range(&q);
1657 assert_eq!(r.function, RangeFunction::AvgOverTime);
1658 assert_eq!(
1659 r.unwrap,
1660 Some(Unwrap {
1661 label: "duration".into(),
1662 conversion: None,
1663 })
1664 );
1665 assert_eq!(r.log_query.pipeline.len(), 1);
1667 assert!(matches!(r.log_query.pipeline[0], PipelineStage::Json(_)));
1668 }
1669
1670 #[test]
1671 fn parses_quantile_over_time_param() {
1672 let q = metric(r#"quantile_over_time(0.99, {a="b"} | unwrap latency [5m])"#);
1673 let r = as_range(&q);
1674 assert_eq!(r.function, RangeFunction::QuantileOverTime);
1675 assert_eq!(r.param, Some(0.99));
1676 assert_eq!(r.unwrap.as_ref().unwrap().label, "latency");
1677 }
1678
1679 #[test]
1680 fn parses_vector_aggregation_with_grouping() {
1681 let q = metric(r#"sum by (level) (rate({job="api"}[5m]))"#);
1682 let v = as_vector(&q);
1683 assert_eq!(v.function, AggregationFunction::Sum);
1684 assert_eq!(
1685 v.grouping,
1686 Some(Grouping {
1687 without: false,
1688 labels: vec!["level".into()],
1689 })
1690 );
1691 assert!(matches!(v.inner, MetricQuery::Range(_)));
1692 }
1693
1694 #[test]
1695 fn parses_trailing_grouping() {
1696 let q = metric(r#"sum(rate({a="b"}[5m])) without (pod, ns)"#);
1697 let v = as_vector(&q);
1698 assert_eq!(
1699 v.grouping,
1700 Some(Grouping {
1701 without: true,
1702 labels: vec!["pod".into(), "ns".into()],
1703 })
1704 );
1705 }
1706
1707 #[test]
1708 fn parses_topk_with_param_and_nested_aggregation() {
1709 let q = metric(r#"topk(10, sum by (path) (rate({job="api"}[5m])))"#);
1710 let v = as_vector(&q);
1711 assert_eq!(v.function, AggregationFunction::Topk);
1712 assert_eq!(v.param, Some(10.0));
1713 let inner = as_vector(&v.inner);
1714 assert_eq!(inner.function, AggregationFunction::Sum);
1715 }
1716
1717 #[test]
1718 fn parses_empty_grouping() {
1719 let q = metric(r#"sum by () (rate({a="b"}[5m]))"#);
1720 assert_eq!(
1721 as_vector(&q).grouping.as_ref().unwrap().labels,
1722 Vec::<String>::new()
1723 );
1724 }
1725
1726 #[test]
1727 fn parses_binary_arithmetic_with_scalar() {
1728 let q = metric(r#"rate({a="b"}[5m]) * 60"#);
1729 let b = as_binary(&q);
1730 assert_eq!(b.op, BinOp::Mul);
1731 assert!(matches!(b.left, MetricQuery::Range(_)));
1732 assert_eq!(b.right, MetricQuery::Literal(60.0));
1733 }
1734
1735 #[test]
1736 fn binary_operator_precedence() {
1737 let q = metric(r#"rate({a="b"}[1m]) + rate({a="c"}[1m]) * 2"#);
1739 let b = as_binary(&q);
1740 assert_eq!(b.op, BinOp::Add);
1741 assert_eq!(as_binary(&b.right).op, BinOp::Mul);
1742 }
1743
1744 #[test]
1745 fn pow_is_right_associative() {
1746 let q = metric("2 ^ 3 ^ 2");
1748 let b = as_binary(&q);
1749 assert_eq!(b.op, BinOp::Pow);
1750 assert_eq!(b.left, MetricQuery::Literal(2.0));
1751 assert_eq!(as_binary(&b.right).op, BinOp::Pow);
1752 }
1753
1754 #[test]
1755 fn logical_operators_bind_loosest() {
1756 let q =
1758 metric(r#"rate({a="1"}[1m]) > 1 and rate({a="2"}[1m]) > 2 or rate({a="3"}[1m]) > 3"#);
1759 let top = as_binary(&q);
1760 assert_eq!(top.op, BinOp::Or);
1761 assert_eq!(as_binary(&top.left).op, BinOp::And);
1762 }
1763
1764 #[test]
1765 fn parses_bool_modifier_on_comparison() {
1766 let q = metric(r#"rate({a="b"}[5m]) > bool 5"#);
1767 let b = as_binary(&q);
1768 assert_eq!(b.op, BinOp::Gt);
1769 assert!(b.bool_modifier);
1770 assert_eq!(b.right, MetricQuery::Literal(5.0));
1771 }
1772
1773 #[test]
1774 fn parses_parenthesized_and_unary_minus() {
1775 let q = metric(r#"(rate({a="b"}[5m]))"#);
1776 assert!(matches!(q, MetricQuery::Range(_)));
1777
1778 let neg = metric(r#"- rate({a="b"}[5m])"#);
1779 let b = as_binary(&neg);
1780 assert_eq!(b.op, BinOp::Sub);
1781 assert_eq!(b.left, MetricQuery::Literal(0.0));
1782 }
1783
1784 #[test]
1785 fn parse_dispatches_log_vs_metric() {
1786 assert!(matches!(parse(r#"{job="api"}"#).unwrap(), Expr::Log(_)));
1787 assert!(matches!(
1788 parse(r#"{job="api"} |= "x""#).unwrap(),
1789 Expr::Log(_)
1790 ));
1791 assert!(matches!(
1792 parse(r#"rate({job="api"}[5m])"#).unwrap(),
1793 Expr::Metric(_)
1794 ));
1795 assert!(matches!(
1796 parse(r#"sum(rate({a="b"}[1m]))"#).unwrap(),
1797 Expr::Metric(_)
1798 ));
1799 }
1800
1801 #[test]
1802 fn rejects_missing_range_window() {
1803 let err = parse_metric_query(r#"rate({a="b"})"#).unwrap_err();
1804 assert!(
1805 err.message.contains("range window") || err.message.contains("'['"),
1806 "{err}"
1807 );
1808 }
1809
1810 #[test]
1811 fn rejects_unknown_metric_function() {
1812 let err = parse_metric_query(r#"frobnicate({a="b"}[5m])"#).unwrap_err();
1813 assert!(err.message.contains("unknown metric function"), "{err}");
1814 }
1815
1816 #[test]
1817 fn rejects_missing_quantile_param() {
1818 let err = parse_metric_query(r#"quantile_over_time({a="b"} | unwrap x [5m])"#).unwrap_err();
1819 assert!(
1820 err.message.contains("scalar parameter") || err.message.contains("','"),
1821 "{err}"
1822 );
1823 }
1824
1825 #[test]
1826 fn rejects_unclosed_aggregation_paren() {
1827 let err = parse_metric_query(r#"sum(rate({a="b"}[5m])"#).unwrap_err();
1828 assert!(err.message.contains("')'"), "{err}");
1829 }
1830
1831 #[test]
1834 fn parses_offset_after_aggregation() {
1835 let q = metric(r#"count_over_time({job="mysql"}[5m]) offset 5m"#);
1836 assert_eq!(as_range(&q).offset, Some(Duration::from_secs(300)));
1837 }
1838
1839 #[test]
1840 fn parses_parenthesized_selector_in_range() {
1841 let q = metric(r#"rate(({job="mysql"} |= "error" != "timeout")[10s])"#);
1842 let r = as_range(&q);
1843 assert_eq!(r.range, Duration::from_secs(10));
1844 assert_eq!(r.log_query.pipeline.len(), 2);
1845 }
1846
1847 #[test]
1848 fn parses_vector_literal() {
1849 assert_eq!(metric("vector(0)"), MetricQuery::VectorLiteral(0.0));
1850 let q = metric(r#"sum(count_over_time({a="b"}[5m])) or vector(0)"#);
1852 let b = as_binary(&q);
1853 assert_eq!(b.op, BinOp::Or);
1854 assert_eq!(b.right, MetricQuery::VectorLiteral(0.0));
1855 }
1856
1857 #[test]
1858 fn parses_label_replace() {
1859 let q = metric(
1860 r#"label_replace(sum(rate({job="api"}[5m])) by (instance), "host", "$1", "instance", "(.*):.*")"#,
1861 );
1862 let MetricQuery::LabelReplace(lr) = &q else {
1863 panic!("expected label_replace, got {q:?}");
1864 };
1865 assert_eq!(lr.dst_label, "host");
1866 assert_eq!(lr.replacement, "$1");
1867 assert_eq!(lr.src_label, "instance");
1868 assert_eq!(lr.regex, "(.*):.*");
1869 assert!(matches!(lr.inner, MetricQuery::Vector(_)));
1870 }
1871}