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