Skip to main content

logql/
parser.rs

1//! # LogQL Parser
2//!
3//! Recursive-descent parser over the [`crate::lexer`] token stream.
4//! Covers stream selectors and log pipelines (line filters, parser
5//! stages, label filters, formatters, unwrap); metric queries follow in
6//! a later phase of the epic.
7
8use 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/// A top-level LogQL expression: either a log query (returns log lines)
21/// or a metric query (returns numeric samples).
22#[derive(Debug, Clone, PartialEq)]
23#[non_exhaustive]
24pub enum Expr {
25    Log(LogQuery),
26    Metric(MetricQuery),
27}
28
29/// Parse error with 1-based source position.
30///
31/// `#[non_exhaustive]` for the same reason as [`crate::LexError`].
32#[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
51/// Parse a full log query: a stream selector followed by an optional
52/// pipeline. Metric-query wrappers are not parsed here.
53pub 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
61/// Parse a bare stream selector, as sent by the metadata endpoints'
62/// `match[]` parameter.
63pub 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
70/// Parse a top-level LogQL expression, dispatching between a log query
71/// and a metric query. A query beginning with `{` is a log query; any
72/// other start (a range/vector function, a number, or a parenthesis) is
73/// a metric query.
74pub 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
87/// Parse a metric query (rejects a bare log query).
88pub 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    /// Position just past the last token, for end-of-input errors.
99    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    /// Parse zero or more pipeline stages following a stream selector.
161    ///
162    /// `|=`, `!=`, `|~`, `!~` introduce line filters; `|` introduces a
163    /// parser stage, formatter, `unwrap`, or label filter, resolved by
164    /// the token that follows.
165    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    /// The operand of a line filter: a quoted string, or `ip("...")`.
204    fn parse_line_filter_value(&mut self, op: LineFilterOp) -> Result<LineFilter, ParseError> {
205        // `ip("...")` matcher.
206        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    /// Consume a `,` if the next token is one, for comma-separated lists.
231    /// Returns whether a comma was consumed.
232    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    /// Consume a leading `ip` identifier if present, so a caller can follow
241    /// up with [`Self::parse_ip_call`] to parse the rest of `ip(...)`.
242    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    /// The `("...")` argument of an `ip(...)` matcher; `ip` is consumed.
254    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    /// Parse the stage that follows a bare `|`.
262    fn parse_pipe_stage(&mut self) -> Result<PipelineStage, ParseError> {
263        // `unwrap` is a keyword; every other stage head is an identifier.
264        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        // A parenthesized label-filter group, e.g. `| (a="1" or b="2")`.
272        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            // Anything else is a label filter expression (it starts with
343            // a label name, which is an identifier).
344            _ => 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    /// An identifier or a keyword used as an identifier.
361    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    /// Optional comma-separated label extractions for `json`/`logfmt`.
373    /// Each is `name` or `name="expression"`. Stops at the next stage.
374    fn parse_label_extractions(&mut self) -> Result<Vec<LabelExtraction>, ParseError> {
375        let mut out = Vec::new();
376        // No extraction params when the next token isn't an identifier.
377        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    /// Comma-separated `label_format` assignments: `dst=src` (rename) or
397    /// `dst="template"`.
398    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    /// Comma-separated bare label names for `distinct`.
427    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    /// Consume any leading `--flag` tokens (parser-stage options).
436    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    /// Comma-separated `drop`/`keep` items: a bare label name or a
446    /// `name op "value"` matcher.
447    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    /// `unwrap <label>` or `unwrap <conversion>(<label>)`.
470    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    /// Label-filter expression with `or` (loosest), then `and` / `,`.
489    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        // Both `and` and a bare comma mean conjunction.
502        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    /// A parenthesized sub-expression or a single predicate.
514    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        // `ip("...")` matcher.
561        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    /// Reject operator/value combinations that don't type-check: regex
582    /// matchers require a string or ip; ordered comparisons require a
583    /// number, duration, or bytes.
584    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    /// `{` [matcher {`,` matcher} [`,`]] `}`
616    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    /// `name (= | != | =~ | !~) "value"`
657    fn parse_matcher(&mut self) -> Result<LabelMatcher, ParseError> {
658        // Grammar keywords are valid label names inside a selector
659        // (`{by="x"}` selects the label "by").
660        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    // ---- metric queries (#372) ----
697
698    /// Metric expression with full binary-operator precedence.
699    fn parse_metric_expr(&mut self) -> Result<MetricQuery, ParseError> {
700        self.parse_binary(0)
701    }
702
703    /// Precedence-climbing binary-operator parser. `min_prec` is the
704    /// lowest binding power this call will consume.
705    ///
706    /// Tiers, loosest to tightest: `or` (1); `and`/`unless` (2);
707    /// comparisons (3); `+`/`-` (4); `*`/`/`/`%` (5); `^` (6,
708    /// right-associative). Unary and atoms bind tighter still.
709    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(); // consume operator
716
717            // Optional `bool` modifier on comparison operators.
718            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            // Optional `on (...)` / `ignoring (...)` vector-matching clause.
728            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    /// Optional `on (labels)` / `ignoring (labels)` clause, with an optional
744    /// trailing `group_left` / `group_right [ (labels) ]` modifier that is
745    /// accepted but recorded only as a flag (matching is one-to-one).
746    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        // Optional `group_left` / `group_right`, each with an optional
756        // parenthesised label list we consume and ignore.
757        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    /// Parse a parenthesised, comma-separated label list: `(a, b, c)`.
776    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    /// Map the upcoming token to a binary operator and its precedence.
792    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    /// A unary-prefixed metric atom (`-x` negates a scalar/vector).
815    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            // Represent `-x` as `0 - x`.
820            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    /// A metric atom: parenthesized expr, scalar literal, range
836    /// aggregation, or vector aggregation.
837    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    /// `func ( [param,] logRangeExpr )` where `logRangeExpr` is a log
873    /// selector/pipeline carrying a `[range]`, plus optional `offset`
874    /// and `unwrap`; unwrapped forms may carry a trailing grouping.
875    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        // `offset` may also trail the aggregation: `count_over_time(...) offset 5m`.
887        if offset.is_none() {
888            offset = self.parse_optional_offset()?;
889        }
890
891        // A grouping may trail an unwrapped range aggregation.
892        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    /// `vector ( <scalar> )`.
906    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    /// `label_replace ( v, dst, replacement, src, regex )`.
915    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    /// Parse the `{selector} pipeline [range] [offset d] [| unwrap ...]`
940    /// core of a range aggregation. The `[range]` may appear before or
941    /// after the unwrap stage, matching Loki's grammar.
942    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        // The log expression may be wrapped in parentheses:
954        // `rate(({job="x"} |= "e")[5m])`.
955        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        // Range window `[Nd]`.
969        let range = self.parse_range_window()?;
970        let offset = self.parse_optional_offset()?;
971
972        // In `{..} | unwrap x [5m]`, the unwrap is the last pipeline
973        // stage and the range follows it; lift it into the aggregation.
974        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    /// `[ <duration> ]`
996    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    /// Optional `offset <duration>`.
1015    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    /// `agg [by/without (labels)] ( [param,] inner )` — grouping may also
1033    /// trail the parenthesized inner query.
1034    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        // Grouping may precede the argument list.
1039        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        // ...or after it (`sum(...) by (label)`).
1047        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    /// Optional `by (...)` / `without (...)` clause.
1060    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    /// A bare numeric literal.
1072    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    /// A leading `<scalar>,` argument for functions where `takes_param` is
1085    /// true (e.g. `quantile_over_time(0.9, ...)`), else `None`.
1086    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
1100/// Maps a matcher-operator token (`=`, `!=`, `=~`, `!~`) to its `MatchOp`,
1101/// or `None` if `token` isn't a matcher operator.
1102fn 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
1112/// Whether an operator is a comparison (may carry a `bool` modifier).
1113fn 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    // ---- pipeline stages (#371) ----
1232
1233    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        // `(a or b) and c` groups the or under the and.
1350        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        // `a and b or c` parses as `(a and b) or c`.
1473        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    // ---- metric queries (#372) ----
1554
1555    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        // `group_left` is accepted and flagged.
1596        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        // No clause → None.
1601        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        // The unwrap stage is lifted out of the pipeline.
1666        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        // `a + b * c` → `a + (b * c)`
1738        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        // `2 ^ 3 ^ 2` → `2 ^ (3 ^ 2)`
1747        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        // `a > 1 and b > 2 or c > 3` → `((a>1) and (b>2)) or (c>3)`
1757        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    // ---- extended metric surface (#661) ----
1832
1833    #[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        // `... or vector(0)` fallback.
1851        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}