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    /// A matcher name may spell a real dotted OTel attribute key directly,
1224    /// alongside a plain (well-known) label name in the same selector.
1225    #[test]
1226    fn dotted_matcher_name_parses() {
1227        assert_eq!(
1228            parse_selector(r#"{k8s.pod.name="x", level="error"}"#)
1229                .unwrap()
1230                .matchers,
1231            vec![
1232                matcher("k8s.pod.name", MatchOp::Eq, "x"),
1233                matcher("level", MatchOp::Eq, "error"),
1234            ]
1235        );
1236    }
1237
1238    #[test]
1239    fn keywords_are_valid_label_names() {
1240        assert_eq!(
1241            parse_selector(r#"{by="x", offset!="y"}"#).unwrap().matchers,
1242            vec![
1243                matcher("by", MatchOp::Eq, "x"),
1244                matcher("offset", MatchOp::Neq, "y"),
1245            ]
1246        );
1247    }
1248
1249    #[test]
1250    fn parse_query_returns_empty_pipeline() {
1251        let query = parse_query(r#"{job="api"}"#).unwrap();
1252        assert_eq!(query.selector.matchers.len(), 1);
1253        assert!(query.pipeline.is_empty());
1254    }
1255
1256    #[test]
1257    fn parse_query_parses_a_line_filter_pipeline() {
1258        let query = parse_query(r#"{job="api"} |= "error""#).unwrap();
1259        assert_eq!(query.selector.matchers.len(), 1);
1260        assert_eq!(
1261            query.pipeline,
1262            vec![PipelineStage::LineFilter(LineFilter {
1263                op: LineFilterOp::Contains,
1264                value: "error".to_string(),
1265                is_ip: false,
1266            })]
1267        );
1268    }
1269
1270    #[test]
1271    fn rejects_missing_brace() {
1272        let err = parse_selector(r#"{job="api""#).unwrap_err();
1273        assert!(err.message.contains("missing '}'"), "{err}");
1274    }
1275
1276    #[test]
1277    fn rejects_missing_operator_and_value() {
1278        let err = parse_selector(r#"{job}"#).unwrap_err();
1279        assert!(err.message.contains("matcher operator"), "{err}");
1280
1281        let err = parse_selector(r#"{job=}"#).unwrap_err();
1282        assert!(err.message.contains("quoted label value"), "{err}");
1283
1284        let err = parse_selector(r#"{job=api}"#).unwrap_err();
1285        assert!(err.message.contains("quoted label value"), "{err}");
1286    }
1287
1288    #[test]
1289    fn rejects_missing_selector() {
1290        let err = parse_selector(r#"job="api""#).unwrap_err();
1291        assert!(err.message.contains("'{'"), "{err}");
1292    }
1293
1294    #[test]
1295    fn error_positions_point_at_offending_token() {
1296        let err = parse_selector("{job =\n  5}").unwrap_err();
1297        assert_eq!((err.line, err.col), (2, 3));
1298    }
1299
1300    #[test]
1301    fn lex_errors_propagate_with_position() {
1302        let err = parse_selector(r#"{job="unterminated}"#).unwrap_err();
1303        assert!(err.message.contains("unterminated"), "{err}");
1304    }
1305
1306    // ---- pipeline stages (#371) ----
1307
1308    fn pipeline(input: &str) -> Vec<PipelineStage> {
1309        parse_query(input).expect("parse").pipeline
1310    }
1311
1312    fn line(op: LineFilterOp, value: &str) -> PipelineStage {
1313        PipelineStage::LineFilter(LineFilter {
1314            op,
1315            value: value.to_string(),
1316            is_ip: false,
1317        })
1318    }
1319
1320    #[test]
1321    fn parses_all_line_filter_operators() {
1322        assert_eq!(
1323            pipeline(r#"{a="b"} |= "keep" != "drop" |~ "re" !~ "nre""#),
1324            vec![
1325                line(LineFilterOp::Contains, "keep"),
1326                line(LineFilterOp::NotContains, "drop"),
1327                line(LineFilterOp::Regex, "re"),
1328                line(LineFilterOp::NotRegex, "nre"),
1329            ]
1330        );
1331    }
1332
1333    #[test]
1334    fn parses_json_and_logfmt_with_and_without_extractions() {
1335        assert_eq!(
1336            pipeline(r#"{a="b"} | json"#),
1337            vec![PipelineStage::Json(vec![])]
1338        );
1339        assert_eq!(
1340            pipeline(r#"{a="b"} | json status="response.status", method"#),
1341            vec![PipelineStage::Json(vec![
1342                LabelExtraction {
1343                    name: "status".into(),
1344                    expr: Some("response.status".into()),
1345                },
1346                LabelExtraction {
1347                    name: "method".into(),
1348                    expr: None,
1349                },
1350            ])]
1351        );
1352        assert_eq!(
1353            pipeline(r#"{a="b"} | logfmt"#),
1354            vec![PipelineStage::Logfmt(LogfmtStage::default())]
1355        );
1356    }
1357
1358    #[test]
1359    fn parses_logfmt_flags() {
1360        assert_eq!(
1361            pipeline(r#"{a="b"} | logfmt --strict --keep-empty host"#),
1362            vec![PipelineStage::Logfmt(LogfmtStage {
1363                flags: vec!["strict".into(), "keep-empty".into()],
1364                extractions: vec![LabelExtraction {
1365                    name: "host".into(),
1366                    expr: None,
1367                }],
1368            })]
1369        );
1370    }
1371
1372    #[test]
1373    fn parses_decolorize_and_distinct() {
1374        assert_eq!(
1375            pipeline(r#"{a="b"} | decolorize"#),
1376            vec![PipelineStage::Decolorize]
1377        );
1378        assert_eq!(
1379            pipeline(r#"{a="b"} | distinct host, path"#),
1380            vec![PipelineStage::Distinct(vec!["host".into(), "path".into()])]
1381        );
1382    }
1383
1384    #[test]
1385    fn parses_ip_line_and_label_filters() {
1386        assert_eq!(
1387            pipeline(r#"{a="b"} |= ip("192.168.4.5/16")"#),
1388            vec![PipelineStage::LineFilter(LineFilter {
1389                op: LineFilterOp::Contains,
1390                value: "192.168.4.5/16".into(),
1391                is_ip: true,
1392            })]
1393        );
1394        assert_eq!(
1395            pipeline(r#"{a="b"} | logfmt | addr = ip("10.0.0.0/8")"#),
1396            vec![
1397                PipelineStage::Logfmt(LogfmtStage::default()),
1398                PipelineStage::LabelFilter(LabelFilterExpr::Pred(LabelFilterPred {
1399                    name: "addr".into(),
1400                    op: FilterOp::Eq,
1401                    value: FilterValue::Ip("10.0.0.0/8".into()),
1402                })),
1403            ]
1404        );
1405    }
1406
1407    #[test]
1408    fn parses_bytes_label_filter() {
1409        assert_eq!(
1410            pipeline(r#"{a="b"} | logfmt | size > 20KB"#),
1411            vec![
1412                PipelineStage::Logfmt(LogfmtStage::default()),
1413                PipelineStage::LabelFilter(LabelFilterExpr::Pred(LabelFilterPred {
1414                    name: "size".into(),
1415                    op: FilterOp::Gt,
1416                    value: FilterValue::Bytes(20_000),
1417                })),
1418            ]
1419        );
1420    }
1421
1422    #[test]
1423    fn parses_parenthesized_label_filter() {
1424        // `(a or b) and c` groups the or under the and.
1425        let stages = pipeline(r#"{x="y"} | (a="1" or b="2") and c="3""#);
1426        let PipelineStage::LabelFilter(LabelFilterExpr::And(left, right)) = &stages[0] else {
1427            panic!("expected top-level And, got {:?}", stages[0]);
1428        };
1429        assert!(matches!(**left, LabelFilterExpr::Or(_, _)));
1430        assert!(matches!(**right, LabelFilterExpr::Pred(_)));
1431    }
1432
1433    #[test]
1434    fn parses_drop_keep_with_matchers() {
1435        assert_eq!(
1436            pipeline(r#"{a="b"} | json | drop __error__, method="GET""#),
1437            vec![
1438                PipelineStage::Json(vec![]),
1439                PipelineStage::Drop(vec![
1440                    LabelPredicate {
1441                        name: "__error__".into(),
1442                        matcher: None,
1443                    },
1444                    LabelPredicate {
1445                        name: "method".into(),
1446                        matcher: Some((MatchOp::Eq, "GET".into())),
1447                    },
1448                ]),
1449            ]
1450        );
1451    }
1452
1453    #[test]
1454    fn parses_regexp_pattern_unpack() {
1455        assert_eq!(
1456            pipeline(r#"{a="b"} | regexp "(?P<method>\\w+)""#),
1457            vec![PipelineStage::Regexp(r"(?P<method>\w+)".into())]
1458        );
1459        assert_eq!(
1460            pipeline(r#"{a="b"} | pattern "<method> <path>""#),
1461            vec![PipelineStage::Pattern("<method> <path>".into())]
1462        );
1463        assert_eq!(pipeline(r#"{a="b"} | unpack"#), vec![PipelineStage::Unpack]);
1464    }
1465
1466    #[test]
1467    fn parses_formatters() {
1468        assert_eq!(
1469            pipeline(r#"{a="b"} | line_format "{{.msg}}""#),
1470            vec![PipelineStage::LineFormat("{{.msg}}".into())]
1471        );
1472        assert_eq!(
1473            pipeline(r#"{a="b"} | label_format dst="{{.src}}", renamed=original"#),
1474            vec![PipelineStage::LabelFormat(vec![
1475                LabelFormat {
1476                    dst: "dst".into(),
1477                    value: LabelFormatValue::Template("{{.src}}".into()),
1478                },
1479                LabelFormat {
1480                    dst: "renamed".into(),
1481                    value: LabelFormatValue::Rename("original".into()),
1482                },
1483            ])]
1484        );
1485    }
1486
1487    #[test]
1488    fn parses_drop_and_keep() {
1489        let bare = |name: &str| LabelPredicate {
1490            name: name.to_string(),
1491            matcher: None,
1492        };
1493        assert_eq!(
1494            pipeline(r#"{a="b"} | drop level, source"#),
1495            vec![PipelineStage::Drop(vec![bare("level"), bare("source")])]
1496        );
1497        assert_eq!(
1498            pipeline(r#"{a="b"} | keep pod"#),
1499            vec![PipelineStage::Keep(vec![bare("pod")])]
1500        );
1501    }
1502
1503    #[test]
1504    fn parses_unwrap_forms() {
1505        assert_eq!(
1506            pipeline(r#"{a="b"} | unwrap duration_ms"#),
1507            vec![PipelineStage::Unwrap(Unwrap {
1508                label: "duration_ms".into(),
1509                conversion: None,
1510            })]
1511        );
1512        assert_eq!(
1513            pipeline(r#"{a="b"} | unwrap duration(latency)"#),
1514            vec![PipelineStage::Unwrap(Unwrap {
1515                label: "latency".into(),
1516                conversion: Some("duration".into()),
1517            })]
1518        );
1519    }
1520
1521    #[test]
1522    fn parses_label_filter_string_and_numeric() {
1523        assert_eq!(
1524            pipeline(r#"{a="b"} | level="error""#),
1525            vec![PipelineStage::LabelFilter(LabelFilterExpr::Pred(
1526                LabelFilterPred {
1527                    name: "level".into(),
1528                    op: FilterOp::Eq,
1529                    value: FilterValue::String("error".into()),
1530                }
1531            ))]
1532        );
1533        assert_eq!(
1534            pipeline(r#"{a="b"} | status >= 500"#),
1535            vec![PipelineStage::LabelFilter(LabelFilterExpr::Pred(
1536                LabelFilterPred {
1537                    name: "status".into(),
1538                    op: FilterOp::Gte,
1539                    value: FilterValue::Number(500.0),
1540                }
1541            ))]
1542        );
1543    }
1544
1545    /// A label filter predicate name may also be a dotted attribute key.
1546    #[test]
1547    fn parses_dotted_label_filter_name() {
1548        assert_eq!(
1549            pipeline(r#"{a="b"} | http.response.status_code >= 500"#),
1550            vec![PipelineStage::LabelFilter(LabelFilterExpr::Pred(
1551                LabelFilterPred {
1552                    name: "http.response.status_code".into(),
1553                    op: FilterOp::Gte,
1554                    value: FilterValue::Number(500.0),
1555                }
1556            ))]
1557        );
1558    }
1559
1560    #[test]
1561    fn label_filter_and_or_precedence() {
1562        // `a and b or c` parses as `(a and b) or c`.
1563        let stages = pipeline(r#"{x="y"} | a="1" and b="2" or c="3""#);
1564        let PipelineStage::LabelFilter(expr) = &stages[0] else {
1565            panic!("expected label filter");
1566        };
1567        match expr {
1568            LabelFilterExpr::Or(left, right) => {
1569                assert!(matches!(**left, LabelFilterExpr::And(_, _)));
1570                assert!(matches!(**right, LabelFilterExpr::Pred(_)));
1571            }
1572            other => panic!("expected top-level Or, got {other:?}"),
1573        }
1574    }
1575
1576    #[test]
1577    fn label_filter_comma_is_conjunction() {
1578        let stages = pipeline(r#"{x="y"} | a="1", b="2""#);
1579        let PipelineStage::LabelFilter(expr) = &stages[0] else {
1580            panic!("expected label filter");
1581        };
1582        assert!(matches!(expr, LabelFilterExpr::And(_, _)));
1583    }
1584
1585    #[test]
1586    fn parses_full_pipeline_end_to_end() {
1587        let query = parse_query(
1588            r#"{app="api"} |= "error" | json | status >= 500 | line_format "{{.msg}}""#,
1589        )
1590        .unwrap();
1591        assert_eq!(query.pipeline.len(), 4);
1592        assert!(matches!(query.pipeline[0], PipelineStage::LineFilter(_)));
1593        assert!(matches!(query.pipeline[1], PipelineStage::Json(_)));
1594        assert!(matches!(query.pipeline[2], PipelineStage::LabelFilter(_)));
1595        assert!(matches!(query.pipeline[3], PipelineStage::LineFormat(_)));
1596    }
1597
1598    #[test]
1599    fn duration_label_filter() {
1600        assert_eq!(
1601            pipeline(r#"{a="b"} | logfmt | latency > 1s"#),
1602            vec![
1603                PipelineStage::Logfmt(LogfmtStage::default()),
1604                PipelineStage::LabelFilter(LabelFilterExpr::Pred(LabelFilterPred {
1605                    name: "latency".into(),
1606                    op: FilterOp::Gt,
1607                    value: FilterValue::Duration(std::time::Duration::from_secs(1)),
1608                })),
1609            ]
1610        );
1611    }
1612
1613    #[test]
1614    fn rejects_regex_operator_against_number() {
1615        let err = parse_query(r#"{a="b"} | status =~ 500"#).unwrap_err();
1616        assert!(
1617            err.message.contains("not valid for this value type"),
1618            "{err}"
1619        );
1620    }
1621
1622    #[test]
1623    fn rejects_ordered_comparison_against_string() {
1624        let err = parse_query(r#"{a="b"} | level > "error""#).unwrap_err();
1625        assert!(
1626            err.message.contains("not valid for this value type"),
1627            "{err}"
1628        );
1629    }
1630
1631    #[test]
1632    fn rejects_line_filter_without_string() {
1633        let err = parse_query(r#"{a="b"} |= 5"#).unwrap_err();
1634        assert!(err.message.contains("quoted string"), "{err}");
1635    }
1636
1637    #[test]
1638    fn rejects_dangling_pipe() {
1639        let err = parse_query(r#"{a="b"} |"#).unwrap_err();
1640        assert!(err.message.contains("pipeline stage after '|'"), "{err}");
1641    }
1642
1643    // ---- metric queries (#372) ----
1644
1645    use std::time::Duration;
1646
1647    fn metric(input: &str) -> MetricQuery {
1648        parse_metric_query(input).expect("parse metric")
1649    }
1650
1651    fn as_range(q: &MetricQuery) -> &RangeAggregation {
1652        match q {
1653            MetricQuery::Range(r) => r,
1654            other => panic!("expected range aggregation, got {other:?}"),
1655        }
1656    }
1657
1658    fn as_vector(q: &MetricQuery) -> &VectorAggregation {
1659        match q {
1660            MetricQuery::Vector(v) => v,
1661            other => panic!("expected vector aggregation, got {other:?}"),
1662        }
1663    }
1664
1665    fn as_binary(q: &MetricQuery) -> &BinaryExpr {
1666        match q {
1667            MetricQuery::Binary(b) => b,
1668            other => panic!("expected binary expression, got {other:?}"),
1669        }
1670    }
1671
1672    #[test]
1673    fn parses_on_and_ignoring_vector_matching() {
1674        let on = metric(r#"sum(rate({a="b"}[1m])) / on(service) sum(rate({a="c"}[1m]))"#);
1675        let m = as_binary(&on).matching.as_ref().expect("matching clause");
1676        assert!(m.on);
1677        assert_eq!(m.labels, vec!["service".to_string()]);
1678        assert!(!m.grouped);
1679
1680        let ign = metric(r#"sum(rate({a="b"}[1m])) / ignoring(level) sum(rate({a="c"}[1m]))"#);
1681        let m = as_binary(&ign).matching.as_ref().expect("matching clause");
1682        assert!(!m.on);
1683        assert_eq!(m.labels, vec!["level".to_string()]);
1684
1685        // `group_left` is accepted and flagged.
1686        let grp =
1687            metric(r#"sum(rate({a="b"}[1m])) / on(service) group_left sum(rate({a="c"}[1m]))"#);
1688        assert!(as_binary(&grp).matching.as_ref().unwrap().grouped);
1689
1690        // No clause → None.
1691        let plain = metric(r#"sum(rate({a="b"}[1m])) / sum(rate({a="c"}[1m]))"#);
1692        assert!(as_binary(&plain).matching.is_none());
1693    }
1694
1695    #[test]
1696    fn parses_bare_range_aggregation() {
1697        let q = metric(r#"rate({job="api"}[5m])"#);
1698        let r = as_range(&q);
1699        assert_eq!(r.function, RangeFunction::Rate);
1700        assert_eq!(r.range, Duration::from_secs(300));
1701        assert_eq!(r.log_query.selector.matchers.len(), 1);
1702        assert!(r.log_query.pipeline.is_empty());
1703        assert!(r.offset.is_none() && r.unwrap.is_none() && r.param.is_none());
1704    }
1705
1706    #[test]
1707    fn parses_range_aggregation_over_a_pipeline() {
1708        let q = metric(r#"count_over_time({job="api"} |= "error" [1h])"#);
1709        let r = as_range(&q);
1710        assert_eq!(r.function, RangeFunction::CountOverTime);
1711        assert_eq!(r.range, Duration::from_secs(3600));
1712        assert_eq!(r.log_query.pipeline.len(), 1);
1713        assert!(matches!(
1714            r.log_query.pipeline[0],
1715            PipelineStage::LineFilter(_)
1716        ));
1717    }
1718
1719    #[test]
1720    fn parses_every_range_function_name() {
1721        for (name, func) in [
1722            ("rate", RangeFunction::Rate),
1723            ("rate_counter", RangeFunction::RateCounter),
1724            ("count_over_time", RangeFunction::CountOverTime),
1725            ("bytes_rate", RangeFunction::BytesRate),
1726            ("bytes_over_time", RangeFunction::BytesOverTime),
1727            ("first_over_time", RangeFunction::FirstOverTime),
1728            ("last_over_time", RangeFunction::LastOverTime),
1729            ("absent_over_time", RangeFunction::AbsentOverTime),
1730        ] {
1731            let q = metric(&format!(r#"{name}({{a="b"}}[5m])"#));
1732            assert_eq!(as_range(&q).function, func, "{name}");
1733        }
1734    }
1735
1736    #[test]
1737    fn parses_offset_modifier() {
1738        let q = metric(r#"rate({a="b"}[5m] offset 1h)"#);
1739        let r = as_range(&q);
1740        assert_eq!(r.offset, Some(Duration::from_secs(3600)));
1741    }
1742
1743    #[test]
1744    fn parses_unwrap_range_aggregation() {
1745        let q = metric(r#"avg_over_time({job="api"} | json | unwrap duration [5m])"#);
1746        let r = as_range(&q);
1747        assert_eq!(r.function, RangeFunction::AvgOverTime);
1748        assert_eq!(
1749            r.unwrap,
1750            Some(Unwrap {
1751                label: "duration".into(),
1752                conversion: None,
1753            })
1754        );
1755        // The unwrap stage is lifted out of the pipeline.
1756        assert_eq!(r.log_query.pipeline.len(), 1);
1757        assert!(matches!(r.log_query.pipeline[0], PipelineStage::Json(_)));
1758    }
1759
1760    #[test]
1761    fn parses_quantile_over_time_param() {
1762        let q = metric(r#"quantile_over_time(0.99, {a="b"} | unwrap latency [5m])"#);
1763        let r = as_range(&q);
1764        assert_eq!(r.function, RangeFunction::QuantileOverTime);
1765        assert_eq!(r.param, Some(0.99));
1766        assert_eq!(r.unwrap.as_ref().unwrap().label, "latency");
1767    }
1768
1769    #[test]
1770    fn parses_vector_aggregation_with_grouping() {
1771        let q = metric(r#"sum by (level) (rate({job="api"}[5m]))"#);
1772        let v = as_vector(&q);
1773        assert_eq!(v.function, AggregationFunction::Sum);
1774        assert_eq!(
1775            v.grouping,
1776            Some(Grouping {
1777                without: false,
1778                labels: vec!["level".into()],
1779            })
1780        );
1781        assert!(matches!(v.inner, MetricQuery::Range(_)));
1782    }
1783
1784    /// `by (...)` grouping labels go through the same ident path as matcher
1785    /// and label-filter names, so a dotted attribute key groups too.
1786    #[test]
1787    fn parses_dotted_grouping_label() {
1788        let q = metric(r#"sum by (k8s.pod.name) (count_over_time({level="error"}[5m]))"#);
1789        let v = as_vector(&q);
1790        assert_eq!(v.function, AggregationFunction::Sum);
1791        assert_eq!(
1792            v.grouping,
1793            Some(Grouping {
1794                without: false,
1795                labels: vec!["k8s.pod.name".into()],
1796            })
1797        );
1798    }
1799
1800    #[test]
1801    fn parses_trailing_grouping() {
1802        let q = metric(r#"sum(rate({a="b"}[5m])) without (pod, ns)"#);
1803        let v = as_vector(&q);
1804        assert_eq!(
1805            v.grouping,
1806            Some(Grouping {
1807                without: true,
1808                labels: vec!["pod".into(), "ns".into()],
1809            })
1810        );
1811    }
1812
1813    #[test]
1814    fn parses_topk_with_param_and_nested_aggregation() {
1815        let q = metric(r#"topk(10, sum by (path) (rate({job="api"}[5m])))"#);
1816        let v = as_vector(&q);
1817        assert_eq!(v.function, AggregationFunction::Topk);
1818        assert_eq!(v.param, Some(10.0));
1819        let inner = as_vector(&v.inner);
1820        assert_eq!(inner.function, AggregationFunction::Sum);
1821    }
1822
1823    #[test]
1824    fn parses_empty_grouping() {
1825        let q = metric(r#"sum by () (rate({a="b"}[5m]))"#);
1826        assert_eq!(
1827            as_vector(&q).grouping.as_ref().unwrap().labels,
1828            Vec::<String>::new()
1829        );
1830    }
1831
1832    #[test]
1833    fn parses_binary_arithmetic_with_scalar() {
1834        let q = metric(r#"rate({a="b"}[5m]) * 60"#);
1835        let b = as_binary(&q);
1836        assert_eq!(b.op, BinOp::Mul);
1837        assert!(matches!(b.left, MetricQuery::Range(_)));
1838        assert_eq!(b.right, MetricQuery::Literal(60.0));
1839    }
1840
1841    #[test]
1842    fn binary_operator_precedence() {
1843        // `a + b * c` → `a + (b * c)`
1844        let q = metric(r#"rate({a="b"}[1m]) + rate({a="c"}[1m]) * 2"#);
1845        let b = as_binary(&q);
1846        assert_eq!(b.op, BinOp::Add);
1847        assert_eq!(as_binary(&b.right).op, BinOp::Mul);
1848    }
1849
1850    #[test]
1851    fn pow_is_right_associative() {
1852        // `2 ^ 3 ^ 2` → `2 ^ (3 ^ 2)`
1853        let q = metric("2 ^ 3 ^ 2");
1854        let b = as_binary(&q);
1855        assert_eq!(b.op, BinOp::Pow);
1856        assert_eq!(b.left, MetricQuery::Literal(2.0));
1857        assert_eq!(as_binary(&b.right).op, BinOp::Pow);
1858    }
1859
1860    #[test]
1861    fn logical_operators_bind_loosest() {
1862        // `a > 1 and b > 2 or c > 3` → `((a>1) and (b>2)) or (c>3)`
1863        let q =
1864            metric(r#"rate({a="1"}[1m]) > 1 and rate({a="2"}[1m]) > 2 or rate({a="3"}[1m]) > 3"#);
1865        let top = as_binary(&q);
1866        assert_eq!(top.op, BinOp::Or);
1867        assert_eq!(as_binary(&top.left).op, BinOp::And);
1868    }
1869
1870    #[test]
1871    fn parses_bool_modifier_on_comparison() {
1872        let q = metric(r#"rate({a="b"}[5m]) > bool 5"#);
1873        let b = as_binary(&q);
1874        assert_eq!(b.op, BinOp::Gt);
1875        assert!(b.bool_modifier);
1876        assert_eq!(b.right, MetricQuery::Literal(5.0));
1877    }
1878
1879    #[test]
1880    fn parses_parenthesized_and_unary_minus() {
1881        let q = metric(r#"(rate({a="b"}[5m]))"#);
1882        assert!(matches!(q, MetricQuery::Range(_)));
1883
1884        let neg = metric(r#"- rate({a="b"}[5m])"#);
1885        let b = as_binary(&neg);
1886        assert_eq!(b.op, BinOp::Sub);
1887        assert_eq!(b.left, MetricQuery::Literal(0.0));
1888    }
1889
1890    #[test]
1891    fn parse_dispatches_log_vs_metric() {
1892        assert!(matches!(parse(r#"{job="api"}"#).unwrap(), Expr::Log(_)));
1893        assert!(matches!(
1894            parse(r#"{job="api"} |= "x""#).unwrap(),
1895            Expr::Log(_)
1896        ));
1897        assert!(matches!(
1898            parse(r#"rate({job="api"}[5m])"#).unwrap(),
1899            Expr::Metric(_)
1900        ));
1901        assert!(matches!(
1902            parse(r#"sum(rate({a="b"}[1m]))"#).unwrap(),
1903            Expr::Metric(_)
1904        ));
1905    }
1906
1907    #[test]
1908    fn rejects_missing_range_window() {
1909        let err = parse_metric_query(r#"rate({a="b"})"#).unwrap_err();
1910        assert!(
1911            err.message.contains("range window") || err.message.contains("'['"),
1912            "{err}"
1913        );
1914    }
1915
1916    #[test]
1917    fn rejects_unknown_metric_function() {
1918        let err = parse_metric_query(r#"frobnicate({a="b"}[5m])"#).unwrap_err();
1919        assert!(err.message.contains("unknown metric function"), "{err}");
1920    }
1921
1922    #[test]
1923    fn rejects_missing_quantile_param() {
1924        let err = parse_metric_query(r#"quantile_over_time({a="b"} | unwrap x [5m])"#).unwrap_err();
1925        assert!(
1926            err.message.contains("scalar parameter") || err.message.contains("','"),
1927            "{err}"
1928        );
1929    }
1930
1931    #[test]
1932    fn rejects_unclosed_aggregation_paren() {
1933        let err = parse_metric_query(r#"sum(rate({a="b"}[5m])"#).unwrap_err();
1934        assert!(err.message.contains("')'"), "{err}");
1935    }
1936
1937    // ---- extended metric surface (#661) ----
1938
1939    #[test]
1940    fn parses_offset_after_aggregation() {
1941        let q = metric(r#"count_over_time({job="mysql"}[5m]) offset 5m"#);
1942        assert_eq!(as_range(&q).offset, Some(Duration::from_secs(300)));
1943    }
1944
1945    #[test]
1946    fn parses_parenthesized_selector_in_range() {
1947        let q = metric(r#"rate(({job="mysql"} |= "error" != "timeout")[10s])"#);
1948        let r = as_range(&q);
1949        assert_eq!(r.range, Duration::from_secs(10));
1950        assert_eq!(r.log_query.pipeline.len(), 2);
1951    }
1952
1953    #[test]
1954    fn parses_vector_literal() {
1955        assert_eq!(metric("vector(0)"), MetricQuery::VectorLiteral(0.0));
1956        // `... or vector(0)` fallback.
1957        let q = metric(r#"sum(count_over_time({a="b"}[5m])) or vector(0)"#);
1958        let b = as_binary(&q);
1959        assert_eq!(b.op, BinOp::Or);
1960        assert_eq!(b.right, MetricQuery::VectorLiteral(0.0));
1961    }
1962
1963    #[test]
1964    fn parses_label_replace() {
1965        let q = metric(
1966            r#"label_replace(sum(rate({job="api"}[5m])) by (instance), "host", "$1", "instance", "(.*):.*")"#,
1967        );
1968        let MetricQuery::LabelReplace(lr) = &q else {
1969            panic!("expected label_replace, got {q:?}");
1970        };
1971        assert_eq!(lr.dst_label, "host");
1972        assert_eq!(lr.replacement, "$1");
1973        assert_eq!(lr.src_label, "instance");
1974        assert_eq!(lr.regex, "(.*):.*");
1975        assert!(matches!(lr.inner, MetricQuery::Vector(_)));
1976    }
1977}