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.
53///
54/// # Examples
55///
56/// ```
57/// let q = logql::parse_query(r#"{service_name="api"} |= "error""#)?;
58/// assert_eq!(q.selector.matchers.len(), 1);
59/// assert_eq!(q.pipeline.len(), 1);
60/// # Ok::<(), logql::ParseError>(())
61/// ```
62///
63/// A metric query is rejected here — use [`parse`] to accept either form:
64///
65/// ```
66/// assert!(logql::parse_query(r#"rate({service_name="api"}[5m])"#).is_err());
67/// ```
68pub 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
76/// Parse a bare stream selector, as sent by the metadata endpoints'
77/// `match[]` parameter.
78///
79/// # Examples
80///
81/// ```
82/// use logql::MatchOp;
83///
84/// let selector = logql::parse_selector(r#"{service_name="api", level!="debug"}"#)?;
85/// assert_eq!(selector.matchers.len(), 2);
86/// assert_eq!(selector.matchers[0].name, "service_name");
87/// assert_eq!(selector.matchers[1].op, MatchOp::Neq);
88/// # Ok::<(), logql::ParseError>(())
89/// ```
90pub 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
97/// Parse a top-level LogQL expression, dispatching between a log query
98/// and a metric query. A query beginning with `{` is a log query; any
99/// other start (a range/vector function, a number, or a parenthesis) is
100/// a metric query.
101///
102/// # Examples
103///
104/// ```
105/// use logql::Expr;
106///
107/// assert!(matches!(
108///     logql::parse(r#"{service_name="api"} |= "error""#)?,
109///     Expr::Log(_),
110/// ));
111/// assert!(matches!(
112///     logql::parse(r#"sum by (service_name) (rate({service_name="api"}[5m]))"#)?,
113///     Expr::Metric(_),
114/// ));
115/// # Ok::<(), logql::ParseError>(())
116/// ```
117///
118/// Errors carry a 1-based position, so a caller can underline the offending
119/// token rather than restating the query:
120///
121/// ```
122/// let err = logql::parse("{service_name=}").unwrap_err();
123/// assert_eq!(err.line, 1);
124/// assert!(err.col > 1);
125/// ```
126pub 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
139/// Parse a metric query (rejects a bare log query).
140///
141/// # Examples
142///
143/// ```
144/// let q = logql::parse_metric_query(r#"count_over_time({service_name="api"}[1h])"#)?;
145/// assert!(format!("{q:?}").contains("CountOverTime"));
146/// # Ok::<(), logql::ParseError>(())
147/// ```
148pub 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    /// Position just past the last token, for end-of-input errors.
159    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    /// Parse zero or more pipeline stages following a stream selector.
221    ///
222    /// `|=`, `!=`, `|~`, `!~` introduce line filters; `|` introduces a
223    /// parser stage, formatter, `unwrap`, or label filter, resolved by
224    /// the token that follows.
225    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    /// The operand of a line filter: a quoted string, or `ip("...")`.
264    fn parse_line_filter_value(&mut self, op: LineFilterOp) -> Result<LineFilter, ParseError> {
265        // `ip("...")` matcher.
266        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    /// Consume a `,` if the next token is one, for comma-separated lists.
291    /// Returns whether a comma was consumed.
292    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    /// Consume a leading `ip` identifier if present, so a caller can follow
301    /// up with [`Self::parse_ip_call`] to parse the rest of `ip(...)`.
302    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    /// The `("...")` argument of an `ip(...)` matcher; `ip` is consumed.
314    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    /// Parse the stage that follows a bare `|`.
322    fn parse_pipe_stage(&mut self) -> Result<PipelineStage, ParseError> {
323        // `unwrap` is a keyword; every other stage head is an identifier.
324        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        // A parenthesized label-filter group, e.g. `| (a="1" or b="2")`.
332        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            // Anything else is a label filter expression (it starts with
403            // a label name, which is an identifier).
404            _ => 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    /// An identifier or a keyword used as an identifier.
421    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    /// Optional comma-separated label extractions for `json`/`logfmt`.
433    /// Each is `name` or `name="expression"`. Stops at the next stage.
434    fn parse_label_extractions(&mut self) -> Result<Vec<LabelExtraction>, ParseError> {
435        let mut out = Vec::new();
436        // No extraction params when the next token isn't an identifier.
437        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    /// Comma-separated `label_format` assignments: `dst=src` (rename) or
457    /// `dst="template"`.
458    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    /// Comma-separated bare label names for `distinct`.
487    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    /// Consume any leading `--flag` tokens (parser-stage options).
496    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    /// Comma-separated `drop`/`keep` items: a bare label name or a
506    /// `name op "value"` matcher.
507    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    /// `unwrap <label>` or `unwrap <conversion>(<label>)`.
530    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    /// Label-filter expression with `or` (loosest), then `and` / `,`.
549    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        // Both `and` and a bare comma mean conjunction.
562        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    /// A parenthesized sub-expression or a single predicate.
574    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        // `ip("...")` matcher.
621        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    /// Reject operator/value combinations that don't type-check: regex
642    /// matchers require a string or ip; ordered comparisons require a
643    /// number, duration, or bytes.
644    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    /// `{` [matcher {`,` matcher} [`,`]] `}`
676    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    /// `name (= | != | =~ | !~) "value"`
717    fn parse_matcher(&mut self) -> Result<LabelMatcher, ParseError> {
718        // Grammar keywords are valid label names inside a selector
719        // (`{by="x"}` selects the label "by").
720        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    // ---- metric queries (#372) ----
757
758    /// Metric expression with full binary-operator precedence.
759    fn parse_metric_expr(&mut self) -> Result<MetricQuery, ParseError> {
760        self.parse_binary(0)
761    }
762
763    /// Precedence-climbing binary-operator parser. `min_prec` is the
764    /// lowest binding power this call will consume.
765    ///
766    /// Tiers, loosest to tightest: `or` (1); `and`/`unless` (2);
767    /// comparisons (3); `+`/`-` (4); `*`/`/`/`%` (5); `^` (6,
768    /// right-associative). Unary and atoms bind tighter still.
769    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(); // consume operator
776
777            // Optional `bool` modifier on comparison operators.
778            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            // Optional `on (...)` / `ignoring (...)` vector-matching clause.
788            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    /// Optional `on (labels)` / `ignoring (labels)` clause, with an optional
804    /// trailing `group_left` / `group_right [ (labels) ]` modifier that is
805    /// accepted but recorded only as a flag (matching is one-to-one).
806    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        // Optional `group_left` / `group_right`, each with an optional
816        // parenthesised label list we consume and ignore.
817        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    /// Parse a parenthesised, comma-separated label list: `(a, b, c)`.
836    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    /// Map the upcoming token to a binary operator and its precedence.
852    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    /// A unary-prefixed metric atom (`-x` negates a scalar/vector).
875    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            // Represent `-x` as `0 - x`.
880            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    /// A metric atom: parenthesized expr, scalar literal, range
896    /// aggregation, or vector aggregation.
897    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    /// `func ( [param,] logRangeExpr )` where `logRangeExpr` is a log
933    /// selector/pipeline carrying a `[range]`, plus optional `offset`
934    /// and `unwrap`; unwrapped forms may carry a trailing grouping.
935    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        // `offset` may also trail the aggregation: `count_over_time(...) offset 5m`.
947        if offset.is_none() {
948            offset = self.parse_optional_offset()?;
949        }
950
951        // A grouping may trail an unwrapped range aggregation.
952        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    /// `vector ( <scalar> )`.
966    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    /// `label_replace ( v, dst, replacement, src, regex )`.
975    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    /// Parse the `{selector} pipeline [range] [offset d] [| unwrap ...]`
1000    /// core of a range aggregation. The `[range]` may appear before or
1001    /// after the unwrap stage, matching Loki's grammar.
1002    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        // The log expression may be wrapped in parentheses:
1014        // `rate(({job="x"} |= "e")[5m])`.
1015        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        // Range window `[Nd]`.
1029        let range = self.parse_range_window()?;
1030        let offset = self.parse_optional_offset()?;
1031
1032        // In `{..} | unwrap x [5m]`, the unwrap is the last pipeline
1033        // stage and the range follows it; lift it into the aggregation.
1034        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    /// `[ <duration> ]`
1056    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    /// Optional `offset <duration>`.
1075    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    /// `agg [by/without (labels)] ( [param,] inner )` — grouping may also
1093    /// trail the parenthesized inner query.
1094    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        // Grouping may precede the argument list.
1099        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        // ...or after it (`sum(...) by (label)`).
1107        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    /// Optional `by (...)` / `without (...)` clause.
1120    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    /// A bare numeric literal.
1132    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    /// A leading `<scalar>,` argument for functions where `takes_param` is
1145    /// true (e.g. `quantile_over_time(0.9, ...)`), else `None`.
1146    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
1160/// Maps a matcher-operator token (`=`, `!=`, `=~`, `!~`) to its `MatchOp`,
1161/// or `None` if `token` isn't a matcher operator.
1162fn 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
1172/// Whether an operator is a comparison (may carry a `bool` modifier).
1173fn 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]
1224    fn keywords_are_valid_label_names() {
1225        assert_eq!(
1226            parse_selector(r#"{by="x", offset!="y"}"#).unwrap().matchers,
1227            vec![
1228                matcher("by", MatchOp::Eq, "x"),
1229                matcher("offset", MatchOp::Neq, "y"),
1230            ]
1231        );
1232    }
1233
1234    #[test]
1235    fn parse_query_returns_empty_pipeline() {
1236        let query = parse_query(r#"{job="api"}"#).unwrap();
1237        assert_eq!(query.selector.matchers.len(), 1);
1238        assert!(query.pipeline.is_empty());
1239    }
1240
1241    #[test]
1242    fn parse_query_parses_a_line_filter_pipeline() {
1243        let query = parse_query(r#"{job="api"} |= "error""#).unwrap();
1244        assert_eq!(query.selector.matchers.len(), 1);
1245        assert_eq!(
1246            query.pipeline,
1247            vec![PipelineStage::LineFilter(LineFilter {
1248                op: LineFilterOp::Contains,
1249                value: "error".to_string(),
1250                is_ip: false,
1251            })]
1252        );
1253    }
1254
1255    #[test]
1256    fn rejects_missing_brace() {
1257        let err = parse_selector(r#"{job="api""#).unwrap_err();
1258        assert!(err.message.contains("missing '}'"), "{err}");
1259    }
1260
1261    #[test]
1262    fn rejects_missing_operator_and_value() {
1263        let err = parse_selector(r#"{job}"#).unwrap_err();
1264        assert!(err.message.contains("matcher operator"), "{err}");
1265
1266        let err = parse_selector(r#"{job=}"#).unwrap_err();
1267        assert!(err.message.contains("quoted label value"), "{err}");
1268
1269        let err = parse_selector(r#"{job=api}"#).unwrap_err();
1270        assert!(err.message.contains("quoted label value"), "{err}");
1271    }
1272
1273    #[test]
1274    fn rejects_missing_selector() {
1275        let err = parse_selector(r#"job="api""#).unwrap_err();
1276        assert!(err.message.contains("'{'"), "{err}");
1277    }
1278
1279    #[test]
1280    fn error_positions_point_at_offending_token() {
1281        let err = parse_selector("{job =\n  5}").unwrap_err();
1282        assert_eq!((err.line, err.col), (2, 3));
1283    }
1284
1285    #[test]
1286    fn lex_errors_propagate_with_position() {
1287        let err = parse_selector(r#"{job="unterminated}"#).unwrap_err();
1288        assert!(err.message.contains("unterminated"), "{err}");
1289    }
1290
1291    // ---- pipeline stages (#371) ----
1292
1293    fn pipeline(input: &str) -> Vec<PipelineStage> {
1294        parse_query(input).expect("parse").pipeline
1295    }
1296
1297    fn line(op: LineFilterOp, value: &str) -> PipelineStage {
1298        PipelineStage::LineFilter(LineFilter {
1299            op,
1300            value: value.to_string(),
1301            is_ip: false,
1302        })
1303    }
1304
1305    #[test]
1306    fn parses_all_line_filter_operators() {
1307        assert_eq!(
1308            pipeline(r#"{a="b"} |= "keep" != "drop" |~ "re" !~ "nre""#),
1309            vec![
1310                line(LineFilterOp::Contains, "keep"),
1311                line(LineFilterOp::NotContains, "drop"),
1312                line(LineFilterOp::Regex, "re"),
1313                line(LineFilterOp::NotRegex, "nre"),
1314            ]
1315        );
1316    }
1317
1318    #[test]
1319    fn parses_json_and_logfmt_with_and_without_extractions() {
1320        assert_eq!(
1321            pipeline(r#"{a="b"} | json"#),
1322            vec![PipelineStage::Json(vec![])]
1323        );
1324        assert_eq!(
1325            pipeline(r#"{a="b"} | json status="response.status", method"#),
1326            vec![PipelineStage::Json(vec![
1327                LabelExtraction {
1328                    name: "status".into(),
1329                    expr: Some("response.status".into()),
1330                },
1331                LabelExtraction {
1332                    name: "method".into(),
1333                    expr: None,
1334                },
1335            ])]
1336        );
1337        assert_eq!(
1338            pipeline(r#"{a="b"} | logfmt"#),
1339            vec![PipelineStage::Logfmt(LogfmtStage::default())]
1340        );
1341    }
1342
1343    #[test]
1344    fn parses_logfmt_flags() {
1345        assert_eq!(
1346            pipeline(r#"{a="b"} | logfmt --strict --keep-empty host"#),
1347            vec![PipelineStage::Logfmt(LogfmtStage {
1348                flags: vec!["strict".into(), "keep-empty".into()],
1349                extractions: vec![LabelExtraction {
1350                    name: "host".into(),
1351                    expr: None,
1352                }],
1353            })]
1354        );
1355    }
1356
1357    #[test]
1358    fn parses_decolorize_and_distinct() {
1359        assert_eq!(
1360            pipeline(r#"{a="b"} | decolorize"#),
1361            vec![PipelineStage::Decolorize]
1362        );
1363        assert_eq!(
1364            pipeline(r#"{a="b"} | distinct host, path"#),
1365            vec![PipelineStage::Distinct(vec!["host".into(), "path".into()])]
1366        );
1367    }
1368
1369    #[test]
1370    fn parses_ip_line_and_label_filters() {
1371        assert_eq!(
1372            pipeline(r#"{a="b"} |= ip("192.168.4.5/16")"#),
1373            vec![PipelineStage::LineFilter(LineFilter {
1374                op: LineFilterOp::Contains,
1375                value: "192.168.4.5/16".into(),
1376                is_ip: true,
1377            })]
1378        );
1379        assert_eq!(
1380            pipeline(r#"{a="b"} | logfmt | addr = ip("10.0.0.0/8")"#),
1381            vec![
1382                PipelineStage::Logfmt(LogfmtStage::default()),
1383                PipelineStage::LabelFilter(LabelFilterExpr::Pred(LabelFilterPred {
1384                    name: "addr".into(),
1385                    op: FilterOp::Eq,
1386                    value: FilterValue::Ip("10.0.0.0/8".into()),
1387                })),
1388            ]
1389        );
1390    }
1391
1392    #[test]
1393    fn parses_bytes_label_filter() {
1394        assert_eq!(
1395            pipeline(r#"{a="b"} | logfmt | size > 20KB"#),
1396            vec![
1397                PipelineStage::Logfmt(LogfmtStage::default()),
1398                PipelineStage::LabelFilter(LabelFilterExpr::Pred(LabelFilterPred {
1399                    name: "size".into(),
1400                    op: FilterOp::Gt,
1401                    value: FilterValue::Bytes(20_000),
1402                })),
1403            ]
1404        );
1405    }
1406
1407    #[test]
1408    fn parses_parenthesized_label_filter() {
1409        // `(a or b) and c` groups the or under the and.
1410        let stages = pipeline(r#"{x="y"} | (a="1" or b="2") and c="3""#);
1411        let PipelineStage::LabelFilter(LabelFilterExpr::And(left, right)) = &stages[0] else {
1412            panic!("expected top-level And, got {:?}", stages[0]);
1413        };
1414        assert!(matches!(**left, LabelFilterExpr::Or(_, _)));
1415        assert!(matches!(**right, LabelFilterExpr::Pred(_)));
1416    }
1417
1418    #[test]
1419    fn parses_drop_keep_with_matchers() {
1420        assert_eq!(
1421            pipeline(r#"{a="b"} | json | drop __error__, method="GET""#),
1422            vec![
1423                PipelineStage::Json(vec![]),
1424                PipelineStage::Drop(vec![
1425                    LabelPredicate {
1426                        name: "__error__".into(),
1427                        matcher: None,
1428                    },
1429                    LabelPredicate {
1430                        name: "method".into(),
1431                        matcher: Some((MatchOp::Eq, "GET".into())),
1432                    },
1433                ]),
1434            ]
1435        );
1436    }
1437
1438    #[test]
1439    fn parses_regexp_pattern_unpack() {
1440        assert_eq!(
1441            pipeline(r#"{a="b"} | regexp "(?P<method>\\w+)""#),
1442            vec![PipelineStage::Regexp(r"(?P<method>\w+)".into())]
1443        );
1444        assert_eq!(
1445            pipeline(r#"{a="b"} | pattern "<method> <path>""#),
1446            vec![PipelineStage::Pattern("<method> <path>".into())]
1447        );
1448        assert_eq!(pipeline(r#"{a="b"} | unpack"#), vec![PipelineStage::Unpack]);
1449    }
1450
1451    #[test]
1452    fn parses_formatters() {
1453        assert_eq!(
1454            pipeline(r#"{a="b"} | line_format "{{.msg}}""#),
1455            vec![PipelineStage::LineFormat("{{.msg}}".into())]
1456        );
1457        assert_eq!(
1458            pipeline(r#"{a="b"} | label_format dst="{{.src}}", renamed=original"#),
1459            vec![PipelineStage::LabelFormat(vec![
1460                LabelFormat {
1461                    dst: "dst".into(),
1462                    value: LabelFormatValue::Template("{{.src}}".into()),
1463                },
1464                LabelFormat {
1465                    dst: "renamed".into(),
1466                    value: LabelFormatValue::Rename("original".into()),
1467                },
1468            ])]
1469        );
1470    }
1471
1472    #[test]
1473    fn parses_drop_and_keep() {
1474        let bare = |name: &str| LabelPredicate {
1475            name: name.to_string(),
1476            matcher: None,
1477        };
1478        assert_eq!(
1479            pipeline(r#"{a="b"} | drop level, source"#),
1480            vec![PipelineStage::Drop(vec![bare("level"), bare("source")])]
1481        );
1482        assert_eq!(
1483            pipeline(r#"{a="b"} | keep pod"#),
1484            vec![PipelineStage::Keep(vec![bare("pod")])]
1485        );
1486    }
1487
1488    #[test]
1489    fn parses_unwrap_forms() {
1490        assert_eq!(
1491            pipeline(r#"{a="b"} | unwrap duration_ms"#),
1492            vec![PipelineStage::Unwrap(Unwrap {
1493                label: "duration_ms".into(),
1494                conversion: None,
1495            })]
1496        );
1497        assert_eq!(
1498            pipeline(r#"{a="b"} | unwrap duration(latency)"#),
1499            vec![PipelineStage::Unwrap(Unwrap {
1500                label: "latency".into(),
1501                conversion: Some("duration".into()),
1502            })]
1503        );
1504    }
1505
1506    #[test]
1507    fn parses_label_filter_string_and_numeric() {
1508        assert_eq!(
1509            pipeline(r#"{a="b"} | level="error""#),
1510            vec![PipelineStage::LabelFilter(LabelFilterExpr::Pred(
1511                LabelFilterPred {
1512                    name: "level".into(),
1513                    op: FilterOp::Eq,
1514                    value: FilterValue::String("error".into()),
1515                }
1516            ))]
1517        );
1518        assert_eq!(
1519            pipeline(r#"{a="b"} | status >= 500"#),
1520            vec![PipelineStage::LabelFilter(LabelFilterExpr::Pred(
1521                LabelFilterPred {
1522                    name: "status".into(),
1523                    op: FilterOp::Gte,
1524                    value: FilterValue::Number(500.0),
1525                }
1526            ))]
1527        );
1528    }
1529
1530    #[test]
1531    fn label_filter_and_or_precedence() {
1532        // `a and b or c` parses as `(a and b) or c`.
1533        let stages = pipeline(r#"{x="y"} | a="1" and b="2" or c="3""#);
1534        let PipelineStage::LabelFilter(expr) = &stages[0] else {
1535            panic!("expected label filter");
1536        };
1537        match expr {
1538            LabelFilterExpr::Or(left, right) => {
1539                assert!(matches!(**left, LabelFilterExpr::And(_, _)));
1540                assert!(matches!(**right, LabelFilterExpr::Pred(_)));
1541            }
1542            other => panic!("expected top-level Or, got {other:?}"),
1543        }
1544    }
1545
1546    #[test]
1547    fn label_filter_comma_is_conjunction() {
1548        let stages = pipeline(r#"{x="y"} | a="1", b="2""#);
1549        let PipelineStage::LabelFilter(expr) = &stages[0] else {
1550            panic!("expected label filter");
1551        };
1552        assert!(matches!(expr, LabelFilterExpr::And(_, _)));
1553    }
1554
1555    #[test]
1556    fn parses_full_pipeline_end_to_end() {
1557        let query = parse_query(
1558            r#"{app="api"} |= "error" | json | status >= 500 | line_format "{{.msg}}""#,
1559        )
1560        .unwrap();
1561        assert_eq!(query.pipeline.len(), 4);
1562        assert!(matches!(query.pipeline[0], PipelineStage::LineFilter(_)));
1563        assert!(matches!(query.pipeline[1], PipelineStage::Json(_)));
1564        assert!(matches!(query.pipeline[2], PipelineStage::LabelFilter(_)));
1565        assert!(matches!(query.pipeline[3], PipelineStage::LineFormat(_)));
1566    }
1567
1568    #[test]
1569    fn duration_label_filter() {
1570        assert_eq!(
1571            pipeline(r#"{a="b"} | logfmt | latency > 1s"#),
1572            vec![
1573                PipelineStage::Logfmt(LogfmtStage::default()),
1574                PipelineStage::LabelFilter(LabelFilterExpr::Pred(LabelFilterPred {
1575                    name: "latency".into(),
1576                    op: FilterOp::Gt,
1577                    value: FilterValue::Duration(std::time::Duration::from_secs(1)),
1578                })),
1579            ]
1580        );
1581    }
1582
1583    #[test]
1584    fn rejects_regex_operator_against_number() {
1585        let err = parse_query(r#"{a="b"} | status =~ 500"#).unwrap_err();
1586        assert!(
1587            err.message.contains("not valid for this value type"),
1588            "{err}"
1589        );
1590    }
1591
1592    #[test]
1593    fn rejects_ordered_comparison_against_string() {
1594        let err = parse_query(r#"{a="b"} | level > "error""#).unwrap_err();
1595        assert!(
1596            err.message.contains("not valid for this value type"),
1597            "{err}"
1598        );
1599    }
1600
1601    #[test]
1602    fn rejects_line_filter_without_string() {
1603        let err = parse_query(r#"{a="b"} |= 5"#).unwrap_err();
1604        assert!(err.message.contains("quoted string"), "{err}");
1605    }
1606
1607    #[test]
1608    fn rejects_dangling_pipe() {
1609        let err = parse_query(r#"{a="b"} |"#).unwrap_err();
1610        assert!(err.message.contains("pipeline stage after '|'"), "{err}");
1611    }
1612
1613    // ---- metric queries (#372) ----
1614
1615    use std::time::Duration;
1616
1617    fn metric(input: &str) -> MetricQuery {
1618        parse_metric_query(input).expect("parse metric")
1619    }
1620
1621    fn as_range(q: &MetricQuery) -> &RangeAggregation {
1622        match q {
1623            MetricQuery::Range(r) => r,
1624            other => panic!("expected range aggregation, got {other:?}"),
1625        }
1626    }
1627
1628    fn as_vector(q: &MetricQuery) -> &VectorAggregation {
1629        match q {
1630            MetricQuery::Vector(v) => v,
1631            other => panic!("expected vector aggregation, got {other:?}"),
1632        }
1633    }
1634
1635    fn as_binary(q: &MetricQuery) -> &BinaryExpr {
1636        match q {
1637            MetricQuery::Binary(b) => b,
1638            other => panic!("expected binary expression, got {other:?}"),
1639        }
1640    }
1641
1642    #[test]
1643    fn parses_on_and_ignoring_vector_matching() {
1644        let on = metric(r#"sum(rate({a="b"}[1m])) / on(service) sum(rate({a="c"}[1m]))"#);
1645        let m = as_binary(&on).matching.as_ref().expect("matching clause");
1646        assert!(m.on);
1647        assert_eq!(m.labels, vec!["service".to_string()]);
1648        assert!(!m.grouped);
1649
1650        let ign = metric(r#"sum(rate({a="b"}[1m])) / ignoring(level) sum(rate({a="c"}[1m]))"#);
1651        let m = as_binary(&ign).matching.as_ref().expect("matching clause");
1652        assert!(!m.on);
1653        assert_eq!(m.labels, vec!["level".to_string()]);
1654
1655        // `group_left` is accepted and flagged.
1656        let grp =
1657            metric(r#"sum(rate({a="b"}[1m])) / on(service) group_left sum(rate({a="c"}[1m]))"#);
1658        assert!(as_binary(&grp).matching.as_ref().unwrap().grouped);
1659
1660        // No clause → None.
1661        let plain = metric(r#"sum(rate({a="b"}[1m])) / sum(rate({a="c"}[1m]))"#);
1662        assert!(as_binary(&plain).matching.is_none());
1663    }
1664
1665    #[test]
1666    fn parses_bare_range_aggregation() {
1667        let q = metric(r#"rate({job="api"}[5m])"#);
1668        let r = as_range(&q);
1669        assert_eq!(r.function, RangeFunction::Rate);
1670        assert_eq!(r.range, Duration::from_secs(300));
1671        assert_eq!(r.log_query.selector.matchers.len(), 1);
1672        assert!(r.log_query.pipeline.is_empty());
1673        assert!(r.offset.is_none() && r.unwrap.is_none() && r.param.is_none());
1674    }
1675
1676    #[test]
1677    fn parses_range_aggregation_over_a_pipeline() {
1678        let q = metric(r#"count_over_time({job="api"} |= "error" [1h])"#);
1679        let r = as_range(&q);
1680        assert_eq!(r.function, RangeFunction::CountOverTime);
1681        assert_eq!(r.range, Duration::from_secs(3600));
1682        assert_eq!(r.log_query.pipeline.len(), 1);
1683        assert!(matches!(
1684            r.log_query.pipeline[0],
1685            PipelineStage::LineFilter(_)
1686        ));
1687    }
1688
1689    #[test]
1690    fn parses_every_range_function_name() {
1691        for (name, func) in [
1692            ("rate", RangeFunction::Rate),
1693            ("rate_counter", RangeFunction::RateCounter),
1694            ("count_over_time", RangeFunction::CountOverTime),
1695            ("bytes_rate", RangeFunction::BytesRate),
1696            ("bytes_over_time", RangeFunction::BytesOverTime),
1697            ("first_over_time", RangeFunction::FirstOverTime),
1698            ("last_over_time", RangeFunction::LastOverTime),
1699            ("absent_over_time", RangeFunction::AbsentOverTime),
1700        ] {
1701            let q = metric(&format!(r#"{name}({{a="b"}}[5m])"#));
1702            assert_eq!(as_range(&q).function, func, "{name}");
1703        }
1704    }
1705
1706    #[test]
1707    fn parses_offset_modifier() {
1708        let q = metric(r#"rate({a="b"}[5m] offset 1h)"#);
1709        let r = as_range(&q);
1710        assert_eq!(r.offset, Some(Duration::from_secs(3600)));
1711    }
1712
1713    #[test]
1714    fn parses_unwrap_range_aggregation() {
1715        let q = metric(r#"avg_over_time({job="api"} | json | unwrap duration [5m])"#);
1716        let r = as_range(&q);
1717        assert_eq!(r.function, RangeFunction::AvgOverTime);
1718        assert_eq!(
1719            r.unwrap,
1720            Some(Unwrap {
1721                label: "duration".into(),
1722                conversion: None,
1723            })
1724        );
1725        // The unwrap stage is lifted out of the pipeline.
1726        assert_eq!(r.log_query.pipeline.len(), 1);
1727        assert!(matches!(r.log_query.pipeline[0], PipelineStage::Json(_)));
1728    }
1729
1730    #[test]
1731    fn parses_quantile_over_time_param() {
1732        let q = metric(r#"quantile_over_time(0.99, {a="b"} | unwrap latency [5m])"#);
1733        let r = as_range(&q);
1734        assert_eq!(r.function, RangeFunction::QuantileOverTime);
1735        assert_eq!(r.param, Some(0.99));
1736        assert_eq!(r.unwrap.as_ref().unwrap().label, "latency");
1737    }
1738
1739    #[test]
1740    fn parses_vector_aggregation_with_grouping() {
1741        let q = metric(r#"sum by (level) (rate({job="api"}[5m]))"#);
1742        let v = as_vector(&q);
1743        assert_eq!(v.function, AggregationFunction::Sum);
1744        assert_eq!(
1745            v.grouping,
1746            Some(Grouping {
1747                without: false,
1748                labels: vec!["level".into()],
1749            })
1750        );
1751        assert!(matches!(v.inner, MetricQuery::Range(_)));
1752    }
1753
1754    #[test]
1755    fn parses_trailing_grouping() {
1756        let q = metric(r#"sum(rate({a="b"}[5m])) without (pod, ns)"#);
1757        let v = as_vector(&q);
1758        assert_eq!(
1759            v.grouping,
1760            Some(Grouping {
1761                without: true,
1762                labels: vec!["pod".into(), "ns".into()],
1763            })
1764        );
1765    }
1766
1767    #[test]
1768    fn parses_topk_with_param_and_nested_aggregation() {
1769        let q = metric(r#"topk(10, sum by (path) (rate({job="api"}[5m])))"#);
1770        let v = as_vector(&q);
1771        assert_eq!(v.function, AggregationFunction::Topk);
1772        assert_eq!(v.param, Some(10.0));
1773        let inner = as_vector(&v.inner);
1774        assert_eq!(inner.function, AggregationFunction::Sum);
1775    }
1776
1777    #[test]
1778    fn parses_empty_grouping() {
1779        let q = metric(r#"sum by () (rate({a="b"}[5m]))"#);
1780        assert_eq!(
1781            as_vector(&q).grouping.as_ref().unwrap().labels,
1782            Vec::<String>::new()
1783        );
1784    }
1785
1786    #[test]
1787    fn parses_binary_arithmetic_with_scalar() {
1788        let q = metric(r#"rate({a="b"}[5m]) * 60"#);
1789        let b = as_binary(&q);
1790        assert_eq!(b.op, BinOp::Mul);
1791        assert!(matches!(b.left, MetricQuery::Range(_)));
1792        assert_eq!(b.right, MetricQuery::Literal(60.0));
1793    }
1794
1795    #[test]
1796    fn binary_operator_precedence() {
1797        // `a + b * c` → `a + (b * c)`
1798        let q = metric(r#"rate({a="b"}[1m]) + rate({a="c"}[1m]) * 2"#);
1799        let b = as_binary(&q);
1800        assert_eq!(b.op, BinOp::Add);
1801        assert_eq!(as_binary(&b.right).op, BinOp::Mul);
1802    }
1803
1804    #[test]
1805    fn pow_is_right_associative() {
1806        // `2 ^ 3 ^ 2` → `2 ^ (3 ^ 2)`
1807        let q = metric("2 ^ 3 ^ 2");
1808        let b = as_binary(&q);
1809        assert_eq!(b.op, BinOp::Pow);
1810        assert_eq!(b.left, MetricQuery::Literal(2.0));
1811        assert_eq!(as_binary(&b.right).op, BinOp::Pow);
1812    }
1813
1814    #[test]
1815    fn logical_operators_bind_loosest() {
1816        // `a > 1 and b > 2 or c > 3` → `((a>1) and (b>2)) or (c>3)`
1817        let q =
1818            metric(r#"rate({a="1"}[1m]) > 1 and rate({a="2"}[1m]) > 2 or rate({a="3"}[1m]) > 3"#);
1819        let top = as_binary(&q);
1820        assert_eq!(top.op, BinOp::Or);
1821        assert_eq!(as_binary(&top.left).op, BinOp::And);
1822    }
1823
1824    #[test]
1825    fn parses_bool_modifier_on_comparison() {
1826        let q = metric(r#"rate({a="b"}[5m]) > bool 5"#);
1827        let b = as_binary(&q);
1828        assert_eq!(b.op, BinOp::Gt);
1829        assert!(b.bool_modifier);
1830        assert_eq!(b.right, MetricQuery::Literal(5.0));
1831    }
1832
1833    #[test]
1834    fn parses_parenthesized_and_unary_minus() {
1835        let q = metric(r#"(rate({a="b"}[5m]))"#);
1836        assert!(matches!(q, MetricQuery::Range(_)));
1837
1838        let neg = metric(r#"- rate({a="b"}[5m])"#);
1839        let b = as_binary(&neg);
1840        assert_eq!(b.op, BinOp::Sub);
1841        assert_eq!(b.left, MetricQuery::Literal(0.0));
1842    }
1843
1844    #[test]
1845    fn parse_dispatches_log_vs_metric() {
1846        assert!(matches!(parse(r#"{job="api"}"#).unwrap(), Expr::Log(_)));
1847        assert!(matches!(
1848            parse(r#"{job="api"} |= "x""#).unwrap(),
1849            Expr::Log(_)
1850        ));
1851        assert!(matches!(
1852            parse(r#"rate({job="api"}[5m])"#).unwrap(),
1853            Expr::Metric(_)
1854        ));
1855        assert!(matches!(
1856            parse(r#"sum(rate({a="b"}[1m]))"#).unwrap(),
1857            Expr::Metric(_)
1858        ));
1859    }
1860
1861    #[test]
1862    fn rejects_missing_range_window() {
1863        let err = parse_metric_query(r#"rate({a="b"})"#).unwrap_err();
1864        assert!(
1865            err.message.contains("range window") || err.message.contains("'['"),
1866            "{err}"
1867        );
1868    }
1869
1870    #[test]
1871    fn rejects_unknown_metric_function() {
1872        let err = parse_metric_query(r#"frobnicate({a="b"}[5m])"#).unwrap_err();
1873        assert!(err.message.contains("unknown metric function"), "{err}");
1874    }
1875
1876    #[test]
1877    fn rejects_missing_quantile_param() {
1878        let err = parse_metric_query(r#"quantile_over_time({a="b"} | unwrap x [5m])"#).unwrap_err();
1879        assert!(
1880            err.message.contains("scalar parameter") || err.message.contains("','"),
1881            "{err}"
1882        );
1883    }
1884
1885    #[test]
1886    fn rejects_unclosed_aggregation_paren() {
1887        let err = parse_metric_query(r#"sum(rate({a="b"}[5m])"#).unwrap_err();
1888        assert!(err.message.contains("')'"), "{err}");
1889    }
1890
1891    // ---- extended metric surface (#661) ----
1892
1893    #[test]
1894    fn parses_offset_after_aggregation() {
1895        let q = metric(r#"count_over_time({job="mysql"}[5m]) offset 5m"#);
1896        assert_eq!(as_range(&q).offset, Some(Duration::from_secs(300)));
1897    }
1898
1899    #[test]
1900    fn parses_parenthesized_selector_in_range() {
1901        let q = metric(r#"rate(({job="mysql"} |= "error" != "timeout")[10s])"#);
1902        let r = as_range(&q);
1903        assert_eq!(r.range, Duration::from_secs(10));
1904        assert_eq!(r.log_query.pipeline.len(), 2);
1905    }
1906
1907    #[test]
1908    fn parses_vector_literal() {
1909        assert_eq!(metric("vector(0)"), MetricQuery::VectorLiteral(0.0));
1910        // `... or vector(0)` fallback.
1911        let q = metric(r#"sum(count_over_time({a="b"}[5m])) or vector(0)"#);
1912        let b = as_binary(&q);
1913        assert_eq!(b.op, BinOp::Or);
1914        assert_eq!(b.right, MetricQuery::VectorLiteral(0.0));
1915    }
1916
1917    #[test]
1918    fn parses_label_replace() {
1919        let q = metric(
1920            r#"label_replace(sum(rate({job="api"}[5m])) by (instance), "host", "$1", "instance", "(.*):.*")"#,
1921        );
1922        let MetricQuery::LabelReplace(lr) = &q else {
1923            panic!("expected label_replace, got {q:?}");
1924        };
1925        assert_eq!(lr.dst_label, "host");
1926        assert_eq!(lr.replacement, "$1");
1927        assert_eq!(lr.src_label, "instance");
1928        assert_eq!(lr.regex, "(.*):.*");
1929        assert!(matches!(lr.inner, MetricQuery::Vector(_)));
1930    }
1931}