从 0 到 1 搭建技术中台之报警平台实践：匹配器演进

{  "title": "Web 服务 ServiceB 崩溃报警",  "source": "192.168.0.1",  "error_type": "panic",  "project_name": "ServiceB",  "project_source": "web",  "details": "(call stack)",  //...}

project_source = "web" AND project_name = "ServiceB"

# 完全匹配project_source = "web"# 正则匹配details =~ "duplicate key when insert"

project_source = "web" AND project_name = "ServiceB" OR "error_type" = "panic"

project_source = "web" AND (project_name = "ServiceB" OR "error_type" = "panic")

type PrimitiveMatcher struct {  Label    string  Text     string  IsRegexp bool  re       *regexp.Regexp}
type Matcher struct {  PrimitiveMatcher *PrimitiveMatcher  IsCompound       bool  Operator         MatcherOperator  Operands         []*Matcher}

err = m.parseToken()if err != nil {  return}
err = m.toElements()if err != nil {  return}
return m.buildMatcher()

for i, c := m.expr {  hasLeftDoubleQuote := false  switch c {    case '(':      //...    case ')':      //...    case '=':      //...    case '~'    //...    default:      //...  }}

for i, word := range m.words {  switch strings.ToLower(word) {    case "=":      leftWord, rightWord, _ := m.tryFetchBothSideWord(i)      m.addElement(m.buildPrimitiveMatcher(leftWord, rightWord, false))    case "=~":      leftWord, rightWord, _ := m.tryFetchBothSideWord(i)      m.addElement(m.buildPrimitiveMatcher(leftWord, rightWord, true))    // deal with more cases    default:      // ...}

var (  valueStack Stack  opStack Stack)
for i, element := range m.elements {  switch e := element; {    case e == "(":      opStack.Push("(")    case e == ")":      for op := opStack.Pop(); op != "(" {        rhs, lhs := valueStack.Pop(), valueStack.Pop()        // apply      }    // operators    case isOp(e):      currOp = e      for prevOp := opStack.Peek(); precedence[currOp] <= precedence[prevOp] {        opStack.Pop()        rhs, lhs := valueStack.Pop(), valueStack.Pop()        // apply prevOp      }      opStack.Push(currOp)    default:      valueStack.Push(e)    }}
// deal with the rest valueStack and opStack

// parser.y%token NUMBER%%
// 括号中的 $$ 表示语法左手边 (LHS) 的值// 括号中的 $1、$2、$3 表示语法右手边 (RHS) 的值statement: expression   { printf("= %d\n", $1); }    ;
expression: NUMBER '+' NUMBER   { $$ = $1 + $3; }    |       NUMBER '-' NUMBER   { $$ = $1 - $3; }    |       NUMBER              { $$ = $1; }    ;

// lex.l%{#include "y.tab.h"extern int yylval;%}
%%[0-9]+  { yylval = atoi(yytext); return NUMBER; }[ \t] ;\n return 0;. return yytext[0];%%

# MacOS$ lex lex.l$ yacc -d parser.y$ gcc y.tab.c lex.yy.c -ly -ll -o calculator$ ./calculator> 128 + 128> = 256

%union{  str string  expr *MatchExpr  pexpr *PrimitiveExpr}
%token LABEL VALUE%token REG_EQ AND OR
%type <expr> expr%type <pexpr> pexpr %type <str> LABEL VALUE%type <str> REG_EQ AND OR

%left OR%left AND%left '(' ')'

// 匹配器表达式可以是空字符串，也可以是一个合法的表达式matcher:  { setResult(yylex, &Matcher{}) }| expr  { setResult(yylex, $1) }
// 表达式可能以下之一：//   复合表达式：expr AND expr//   复合表达式：expr OR expr//   原始表达式：pexpr//   括号表达式：(expr)expr: expr AND expr  { $$ = &Matcher{IsCompound: true, Operator:$2, Operands:[]*Matcher{$1,$3}} }| expr OR expr  { $$ = &Matcher{IsCompound: true, Operator:$2, Operands:[]*Matcher{$1,$3}} }| pexpr  { $$ = &Matcher{IsCompound: false, PrimitiveMatcher:$1} }| '(' expr ')'  { $$ = $2 }// 原始表达式要么是 LABEL = VALUE, 要么是 LABEL =~ VALUEpexpr: LABEL '=' VALUE  { $$ = &PrimitiveMatcher{Label:$1, Text:$3, IsRegex: false} }| LABEL REG_EQ VALUE  { $$ = &PrimitiveMatcher{Label:$1, Text:$3, IsRegex: true} }

/[aA][nN][dD]/                      { lval.str = "AND"; return AND }/[oO][rR]/                          { lval.str = "OR"; return OR }/=~/                                { return REG_EQ }/=/                                 { return int(yylex.Text()[0]) }/\(/                                { return int(yylex.Text()[0]) }/\)/                                { return int(yylex.Text()[0]) }/[A-Za-z][A-Za-z0-9_]*/             { lval.str = yylex.Text(); return LABEL }/".*"/                     { lval.str = yylex.Text()[1:len(yylex.Text())-1]; return VALUE }/[ \t\r\n]+/                        { /* white spaces ignored */ }//package c

$ nex nex.l$ goyacc -o parser.go parser.y

// 忽略细节处理func Compile(ctx context.Context, in io.Reader) (m *Matcher, err error) {  lr := NewLexer(in)  yyParse(lr)
  if lr.parseResult == nil {    err = SyntaxError    return  }
  m = lr.parseResult.(*Matcher)  return}

labela = "a" AND (labelb = "b" OR labelc = "c")↑      在LABEL中                 
(labela = "a") OR labelb = "b"↑在'('中

labela = "a" AND (labelb = "b" OR labelc = "c")             ↑            进入[关系运算符]状态(labela = "a")             ↑            进入 ')' 状态labela = "a"            ↑           进入[结束]状态

# start: [开始]; leftParen: '('; label: [标签]; eq: [匹配符]; value: [文本];# rightParen: ')'; binaryOp: [关系运算符]; end: [结束]                                                +------------+                                                | rightParen | -------------+                                                +------------+              |                                                  ^  |                      |                                                  |  |                      |  +----------------------+                        |  ----------------+      |  |                      v                        |                  v      |  |  +-----------+     +-------+     +----+     +------------+     +-----+  |  |  |   start   | --> | label | --> | eq | --> |   value    | --> | end |  |  |  +-----------+     +-------+     +----+     +------------+     +-----+  |  |    |                 ^                        |                         |  |    |                 |                        |                         |  |    v                 |                        v                         |  |  +-----------+       |                      +------------+              |  +- | leftParen |       +--------------------- |  binaryOp  | <------------+     +-----------+                              +------------+       ^                                          |       +------------------------------------------+

type lexer struct {  name  string    // used only for error reports.  input string    // the string being scanned.  start int       // start position of this item.  pos   int       // current position in the input.  width int       // width of last rune read from input.  items chan item // channel of scanned items.}
// stateFn represents the state of the scanner// as a function that returns the next state.type stateFn func(*lexer) stateFn
func (l *lexer) run() {  for state := lexStart; state != nil; {    state = state(l)  }  close(l.items)}

func lexStart(l *lexer) stateFn {}func lexLabel(l *lexer) stateFn {}func lexLeftParen(l *lexer) stateFn {}func lexRightParen(l *lexer) stateFn {}func lexEq(l *lexer) stateFn {}func lexValue(l *lexer) stateFn {}func lexBinaryOp(l *lexer) stateFn {}