Golang高性能事件规则匹配插件库hypermatch的使用

简介

Hypermatch是一个高性能的Go库，能够快速匹配大量规则与事件。它专为速度和效率设计，能够以低延迟处理每秒数千个事件，非常适合实时系统。

主要特性：

• 快速匹配：在内存中以最小延迟将事件与大量规则集匹配
• 可读的规则格式：将规则序列化为人类可读的JSON对象
• 灵活的规则语法：支持多种匹配条件，包括equals、prefix、suffix、wildcard、anything-but、all-of和any-of

事件由字段列表组成，以名称/值对的形式提供。规则将这些事件字段与确定事件是否匹配的模式链接起来。

快速开始

import (
    hypermatch "github.com/SchwarzIT/hypermatch"
)

func main() {
    // 初始化hypermatch
    hm := hypermatch.NewHyperMatch()
    
    // 添加规则
    if err := hm.AddRule("markus_rule", hypermatch.ConditionSet{
        hypermatch.Condition{Path: "firstname", Pattern: hypermatch.Pattern{Type: hypermatch.PatternEquals, Value: "markus"}},
        hypermatch.Condition{Path: "lastname", Pattern: hypermatch.Pattern{Type: hypermatch.PatternEquals, Value: "troßbach"}},
        }); err != nil {
            panic(err)
    }
    
    // 测试匹配
    matchedRules := hm.Match([]hypermatch.Property{
        {Path: "firstname", Values: []string{"markus"}},
        {Path: "lastname", Values: []string{"troßbach"}},
    })
    log.Printf("匹配的规则: %v", matchedRules)
    
    // 测试不匹配
    matchedRules = hm.Match([]hypermatch.Property{
        {Path: "firstname", Values: []string{"john"}},
        {Path: "lastname", Values: []string{"doe"}},
    })
    log.Printf("匹配的规则: %v", matchedRules)
}

示例事件

事件表示为包含各种字段的JSON对象。以下是一个示例事件：

{
        "name": "Too many parallel requests on system xy",
        "severity": "critical",
        "status": "firing",
        "message": "Lorem ipsum dolor sit amet, consetetur sadipscing elitr.",
        "team": "awesome-team",
        "application": "webshop",
        "component": "backend-service",
        "tags": [
            "shop",
            "backend"
        ]   
}

匹配基础

Hypermatch中的规则由ConditionSet类型定义的条件组成。

• 不区分大小写匹配：所有值比较都不区分大小写
• 支持的类型：目前仅支持字符串和字符串数组

每个条件包括：

• Path：要匹配的事件字段
• Pattern：用于匹配指定路径值的模式

以下是一个匹配上述事件的规则示例：

ConditionSet{
    {
        Path: "status",
        Pattern: Pattern{Type: PatternEquals, Value: "firing"},
    },
    {
        Path: "name",
        Pattern: Pattern{Type: PatternAnythingBut, Sub: []Pattern{
                {Type: PatternWildcard, Value: "TEST*"},
            },
        },
    },
    {
        Path: "severity",
        Pattern: Pattern{ Type: PatternAnyOf,
            Sub: []Pattern{
                {Type: PatternEquals, Value: "critical"},
                {Type: PatternEquals, Value: "warning"},
            },
        },
    },
    {
        Path: "tags",
        Pattern: Pattern{ Type: PatternAllOf,
            Sub: []Pattern{
                {Type: PatternEquals, Value: "shop"},
                {Type: PatternEquals, Value: "backend"},
            },
        },
    },
}

规则和条件也可以表示为JSON对象。以下JSON等同于上述Go表示法：

{
    "status": {
        "equals": "firing"
    },
    "name": {
        "anythingBut": [
            {"wildcard": "TEST*"}
        ]
    },
    "severity": {
        "anyOf": [
            {"equals": "critical"},
            {"equals": "warning"}
        ]
    },
    "tags": {
        "allOf": [
            {"equals": "shop"},
            {"equals": "backend"}
        ]
    }
}

匹配语法

“equals” 匹配

equals条件检查事件的属性是否匹配指定值，不区分大小写。

{
    "status": {
        "equals": "firing"
    }
}

如果属性值是：

• 字符串：检查值是否等于"firing"
• 字符串数组：检查数组是否包含等于"firing"的元素

“prefix” 匹配

prefix条件检查属性是否以指定前缀开头，不区分大小写。

{
    "status": {
        "prefix": "fir"
    }
}

如果属性值是：

• 字符串：检查值是否以"fir"开头
• 字符串数组：检查数组是否包含以"fir"开头的元素

“suffix” 匹配

suffix条件检查属性是否以指定后缀结尾，不区分大小写。

{
    "status": {
        "suffix": "ing"
    }
}

如果属性值是：

• 字符串：检查值是否以"ing"结尾
• 字符串数组：检查数组是否包含以"ing"结尾的元素

“wildcard” 匹配

wildcard条件使用通配符匹配属性值，忽略大小写。

• 使用*作为通配符匹配任意数量的字符（包括无字符）
• 不能将通配符直接相邻放置

{
    "name": {
        "wildcard": "*parallel requests*"
    }
}

如果属性值是：

• 字符串：检查值是否匹配模式parallel requests
• 字符串数组：检查数组是否有值匹配该模式

“anythingBut” 匹配

anythingBut条件否定匹配，仅在指定条件不满足时触发。

{
    "status": {
        "anythingBut": [
            {"equals": "firing"}
        ]
    }
}

如果属性值是：

• 字符串：检查值是否不是"firing"
• 字符串数组：检查数组是否不包含等于"firing"的元素

“anyOf” 匹配

anyOf对应布尔"或"运算。它检查多个条件，如果任何条件为真则匹配。

{
    "status": {
        "anyOf": [
            {"equals": "firing"},
            {"equals": "resolved"}
        ]
    }
}

如果属性值是：

• 字符串：检查值是否为"firing"或"resolved"
• 字符串数组：检查数组是否包含等于"firing"或"resolved"或两者的元素

“allOf” 匹配

allOf对应布尔"与"运算。它检查多个条件，如果所有条件都为真则匹配。

{
    "tags": {
        "allOf": [
            {"equals": "shop"},
            {"equals": "backend"}
        ]
    }
}

如果属性值是：

• 字符串：此条件无意义，因为它检查值是否同时等于"shop"和"backend"
• 字符串数组：检查数组是否同时包含"shop"和"backend"

性能

hypermatch设计用于处理大量规则时保持极快速度。为了获得最佳性能，请考虑以下几点：

• 减少规则中的字段数量，条件越少，查找路径越短
• 尽量使事件和规则中的路径多样化，字段越异构，性能越高
• 尽可能减少anyOf条件的数量