cavalieri, 用于监视和警报的C++ 事件流处理工具

分享于 

36分钟阅读

GitHub

  繁體
A C++ event stream processing tool to monitor and alert
  • 源代码名称:cavalieri
  • 源代码网址:http://www.github.com/juruen/cavalieri
  • cavalieri源代码文档
  • cavalieri源代码下载
  • Git URL:
    git://www.github.com/juruen/cavalieri.git
    Git Clone代码到本地:
    git clone http://www.github.com/juruen/cavalieri
    Subversion代码到本地:
    $ svn co --depth empty http://www.github.com/juruen/cavalieri
    Checked out revision 1.
    $ cd repo
    $ svn up trunk
    
    Cavalieri Build Status

    简介

    是一个用于监控distrubuted系统的C++ 事件流处理工具,它是由优秀的 riemann.io 插件项目所启发。

    它实现了原始的riemann.io 协议。 这意味着你可以利用现有的 riemann客户端和工具。 它还尝试在可能的情况下模拟它的流 API。

    当前版本的cavalieri 0.1.2 被认为处于 beta状态。

    背景

    我们在 $DAILY_WORK. 上使用黎曼 我开始这个项目是为了更好地理解黎曼是如何工作的。

    我一直在处理它,它到达了一个有用的地方。

    通过与黎曼服务器并排运行来测试它,似乎稳定的-at至少是used-的子集,用于监视数千个主机的功能。

    下一步是在添加更多功能之前进行重构和清理。

    电子邮件内容

    安装

    软件包

    你可以通过添加这里ppa来安装 Ubuntry 14.04 ( 信任信)的deb软件包:

    
    sudo add-apt-repository ppa:juruen/cavalieri
    
    
    sudo apt-get update
    
    
    sudo apt-get install cavalieri
    
    
    
    
    Debian

    Packges即将推出 !

    基于源代码的

    查看从deb软件包中提取的构建依赖项:

    
    cmake, subversion, protobuf-compiler,libprotobuf-dev, libev-dev, libgflags-dev, 
    
    
    libgoogle-glog-dev, libcurl4-openssl-dev, libssl-dev, libtbb-dev,
    
    
    libjsoncpp-dev, lcov, flex, bison, libgoogle-glog-dev, libboost-filesystem-dev,
    
    
    libboost-system-dev
    
    
    
    
    

    你还需要一个C++11启用的编译器。 GCC> = 4.7或者等效 Clang。

    一旦depencies得到满足。 要生成和安装,请执行以下操作:

    
    mkdir build
    
    
    cd build
    
    
    cmake.. 
    
    
    make install
    
    
    
    

    创建规则

    克隆 cavalieri规则创建你自己的规则的模板项目。

    git clone https://github.com/juruen/cavalieri-rules.gitcd cavalieri-rules

    打开 rules.cpp 并添加你的规则。 默认规则将发送一个包含关键事件的电子邮件,当来自 requests_rate服务的度量值超过时,该邮件将包含一个关键事件。

    #include<rules.h>#include<external/pagerduty.h>#include<external/email.h>streams_tcavalieri_rules() {
     auto mail_stream = email("localhost", "cavalieri@localhost",
     "devops@localhost");
     returnservice("requests_rate")
    >> 上面(40)
    >> set_state("critical")
    >> changed_state()
    >> mail_stream;
    }EXPORT_RULES(cavalieri_rules)

    构建一个包含你的规则的插件,该插件将由 cavalieri 加载。

    mkdir buildcd build
    cmake.. 
    make

    上面的步骤生成一个 librules.so 文件,该文件将装载。

    在构建目录中执行 cavalieri,或者在插件所在的specifify处使用的-rules_directory 标志。

    
    $ cavalieri
    
    
    I0403 23:15:44 config.cpp:36] config:
    
    
    I0403 23:15:44 config.cpp:37] events_port: 5555
    
    
    I0403 23:15:44 config.cpp:38] rimeann_tcp_pool_size:: 1
    
    
    I0403 23:15:44 config.cpp:39] ws_port: 5556
    
    
    I0403 23:15:44 config.cpp:40] ws_pool_size: 1
    
    
    I0403 23:15:44 config.cpp:41] index_expire_interval: 60
    
    
    I0403 23:15:44 config.cpp:42] rules_directory:. 
    
    
    I0403 23:15:44 config.cpp:43] --
    
    
    I0403 23:15:44 rules_loader.cpp:60] rules loaded succesfully from librules.so
    
    
    
    
    

    测试你的规则

    你可以轻松地测试规则,而不用将它们。

    在 cavalieri模板 root 目录有一个 python 脚本that帮助你找出你的规则是否执行你期望的或者不需要的操作。

    它的工作方式非常简单。 打开 test_rules.py,并添加触发警报的事件。 默认情况下,已经有一些事件将触发默认规则的警报:

    events = [
     {'host': 'foo.org', 'service': 'requests_rate', 'metric': 10, 'time': 0},
     {'host': 'foo.org', 'service': 'requests_rate', 'metric': 20, 'time': 60},
     {'host': 'foo.org', 'service': 'requests_rate', 'metric': 40, 'time': 120},
     {'host': 'foo.org', 'service': 'requests_rate', 'metric': 45, 'time': 180},
     {'host': 'foo.org', 'service': 'requests_rate', 'metric': 45, 'time': 240},
     {'host': 'foo.org', 'service': 'requests_rate', 'metric': 20, 'time': 300},
     {'host': 'foo.org', 'service': 'requests_rate', 'metric': 10, 'time': 360}]

    让我们再次看一下缺省规则:

    [...]auto s = service("requests_rate")
    >> 上面(40)
    >> set_state("critical")
    >> changed_state()
    >> mail_stream;
    [...]

    如你所见,在 test_rules.py 中定义的事件将在度量超过 40时触发警报。 这是发生在时间的事件,在时间的时候,180.

    你可以从 /cavalieri模板的root 目录中执行。 当那些事件通过它们时,你会神奇地看到你的规则发生了什么:

    {
     "index" : [],
     "reports" : [
     [
     "email",
     {
     "event" : {
     "description" : "",
     "host" : "foo.org",
     "metric" : 45.0,
     "service" : "requests_rate",
     "state" : "critical",
     "tags" : [],
     "time" : 180 },
     "extra" : "",
     "message" : "send email from: cavalieri@localhost to: devops@localhost",
     "time" : 180 }
     ]
     ]
    }

    就像你在上面的输出中看到的, test_rules.py 报告了一个电子邮件将在发送,to报告requests_rate服务is服务是关键 critical。

    test_rules.py 使用 cavalieri_tester,它可以加载规则并将事件发送给它们。

    但是,它在一个特殊的环境中,所有的外部调用( 如电子邮件或者 pagerduty ) 都被。 它还模拟了调度程序,这意味着你可以在几秒钟内测试几个月的事件。

    这里特性允许你轻松地将警报规则添加到持续集成过程中。

    重新加载规则

    当Cavalieri收到SIGHUP信号时,它将只重新加载已经更改的.so 规则库。

    这允许在多个团队中执行规则的部署,只加载和影响已经更改的命名空间。

    这是黎曼不允许并且可能在多个团队的mantain规则中特别有用的东西。

    发送事件

    你可以使用任何现有的riemann.io 客户端。 让他们将事件发送到运行 cavalieri的主机。

    流 API

    流函数

    什么是流函数? ( )

    它打印出通过它的事件。

    std::string ( const str )

    它打印通过它的事件,以及作为参数的字符串。

    空( )

    可以将它用作不转发事件的接收器。

    服务( const-std::string 服务)

    它将包含给定服务的事件转发。

    ( const-std::vector <std::string> 服务)

    它将包含任何给定服务的事件转发到。 这就像服务,但是它需要一个服务列表而不是单个的服务列表。

    service_like ( const-std::string Pattern )

    它转发服务 MATCH 与给定 Pattern的事件。

    service_like("foo%")>> prn("service starting with foo");
    service_like_any ( const-std::vector <std::string> 模式)

    它将它的服务 MATCH的事件转发给任何给定的Pattern。 这就像 service_like,但是它需要一个模式列表,而不是单个的。

    状态( const-std::string 状态)

    它转发状态设置为状态的事件。

    ( const-std::vector <std::string> 状态)

    它的状态是状态为任何状态。

    has_attribute ( 常量 std::string 属性)

    它的fowards事件有一个属性。

    set_service ( const-std::string 服务)

    它将事件服务设置为服务并将它的转发给。

    set_state ( 常量 std::string 状态)

    它将事件状态设置为状态并将它的转发到。

    set_host ( const-std::string 主机)

    它将事件主机设置为主机并将它的转发到。

    set_metric ( const双精度值) ;

    它将事件度量值设置为值并将它的转发给。

    set_description ( const-std::string 描述) ;

    它将事件度量值设置为描述并将它的转发给。

    set_ttl ( const双 ttl ) ;

    它将事件TTL设置为 tll并将它的转发。

    default_service ( const-std::string 服务)

    如果未设置服务,则将事件服务设置为服务并将它的转发。

    default_state ( 常量 std::string 状态)

    如果未设置状态,则将事件状态设置为状态并将它的转发。

    default_host ( const-std::string 主机)

    如果未设置主机,则将事件主机设置为主机并将它的转发到。

    default_metric ( const双精度值) ;

    如果未设置度量,则将事件的度量值设置为值并将它的转发到。

    default_description ( const-std::string 描述) ;

    如果未设置说明,则将事件的度量值设置为描述并将它的转发到。

    default_ttl ( const双 ttl ) ;

    如果未设置 TTL,它将事件TTL设置为 tll 并将它的转发。

    带( EXP )的

    将这里宏用作创建修改事件的任何字段的流的方法。

    它将 定义为它的范围内的事件。 你可以在它上面调用可变函数。 然后,它负责转发已经修改的事件。

    这是实际的宏:

    #defineWITH(EXP)
     create_stream(
     [](const Event & const_event)
     {
     Event e(const_event);
     (EXP);
     return {e};
     })

    你可以按如下方式使用它:

    // Change host field and descriptionWITH(e.set_host("cluster-001").set_description("aggregated master metrics"));
    ( const split_clauses_t子句)

    它需要一系列的对。 每对都包含一个谓词函数和一个流。 当收到事件时,事件被传递给第一个流,谓词返回 true。

    你可以将这个函数看作是一个的switch 案例语句,其中谓词是例。

    split({{p::上面(10), set_state("ok")},
     {p::under(5), set_state("critical"}});
    ( const-split_clauses_t子句,const-streams_t-default_stream )

    它需要一组对和默认流。 每对都包含一个谓词函数和一个流。 当收到事件时,事件被传递给第一个流,谓词返回 true。 如果没有谓词 MATCH,则事件将传递给默认流。

    你可以将这个函数看作是一个的switch 案例语句,其中谓词是例。

    split({{p::上面(10), set_state("ok")},
     {p::under(5), set_state("critical")}},
     set_state("warning"));

    当一个事件进入我们上面定义的分裂函数时,可能会发生三个不同的场景。

    第一种情况:p::上面(10) 谓词返回 true,因此该事件被转发到 set_state ("ok ok")。

    Split-1

    第二个场景:度量不超过 10,但它在 5下,然后 p::under(5) 返回 true。 然后将事件转发到 set_state ("关键")。

    Split-2

    第三个和最后一个场景:公制在 5和 10之间。 p::上面(10) p::under(5) return return return return return true。 然后将事件发送到默认流。 在本例中,set_state ("警告")。

    Split-3

    请注意,在这三个场景中,通过任何流的结果将是分割后任何流的forwaded。 这意味着下面的代码使用拆分集的状态打印事件。

    split({p::上面(10), set_state("ok")},
     {p::under(5), set_state("critical")},
     set_state("warning"))>> prn ("result after going through split: ")
    ( const-predicate_t &谓词)

    它将使谓词函数为 return true的事件传递给。

    where(p::under(5))>> set_state("critical")>> notiy_email();
    ( const-predicate_t &谓词,const-streams_t-else_stream )

    它将使谓词函数为 return true的事件传递给。 否则,事件将传递给 else_stream。

    上面_stream = set_state("ok")>> prn("metric is 上面 5");where(p::under(5), 上面_stream)>> set_state("critical")>> notiy_email(); 
    ( 常量 by_keys_t &键,const streams_t流)

    它需要一个事件的字段列表。 当事件进入这个函数时,将检索该字段,对于以前还没有看到的每个新值,它将创建一个流并将该事件传递给它。 如果以前看到过值,它将把事件传递给先前创建的流。

    让我们来看看这个。 我们将使用名为 rate的流函数,它简单地和在秒receives收到的事件度量 sums,并将结果除以 dt。 假设服务器每次不能处理请求时都会发送一个称为 backend_exception的事件,我们希望看到每个服务器上的异常率。

    请注意,如果我们只做下面的操作,我们将不会获得每个主机速率,我们会得到全局速率。

    auto rate_stream = set_metric(1)>> rate(60)>> prn("exceptions per second:");

    如果我们想计算每主机的速率,那就是 by()。 它帮助我们复制每个主机的流,这样我们就可以单独计算速率。

    auto rate_stream = set_metric(1)
    >> rate(60)
    >> prn("exceptions per second:");// Use the host field and replicate rate_stream for evey distinct host.by({"host"}, rate_stream);

    你可以将多个字段传递给 by()。

    ( 常量 by_keys_t &键)

    这与( 由 keys_t &键构造,常量streams_t流)的类似。 但是,它不是将流的每个不同组合( 如参数) 传递给克隆,而是复制后连接在一起的流,然后再将它的复制。

    让我们看一下另一个使用这个函数的函数的示例。

    // Use the host field and replicate the stream that is next to it.by({"host"})>> set_metric(1)>> rate(60)>> prn("exceptions per second:");
    ( 常量 uint32 & dt )

    它和 dt的接收事件的度量和。 在此之后,事件被转发,它的度量包含 accumulated dt dt dt accumulated。

    // An easy way to count the rate of events that go through this streamwith({"metric", 1)>> rate(60)>> prn("events per second");
    ( const-fold_fn_t & fold_fn )

    它保存了receivied事件的地图。 事件是通过ttheir主机和服务的组合作为密钥插入到地图中的。

    每次收到新事件时,都会更新地图并将它的中的所有事件转发到折叠函数。

    这里函数对从不同主机聚合度量很有用。

    项目( const谓词,const-fold_fn_t & fold_fn )。

    类似于 coalesce,当你需要一些事件时,更适合你。

    它需要一个谓词列表。 对于每个谓词,MATCHES 存储的最后一个事件。 每当一个新事件到达和 MATCHES 任何谓词时,所有存储的事件都是forwared到的fold_fn。

    // Create a new event metric that is the sum of foo and barproject({p::serviced("foo"), p::service("bar"), sum)>> prn("foo + bar");
    changed_state ( 常量 std::string &初始)

    仅在主机和服务发生状态更改时才转发事件。 它是最初的,作为第一个状态。 它在内部使用了。

    ,sending emails emails useful spam spam spam spam critical critical critical critical critical critical critical critical critical critical send send send。

    changed_state ( )

    仅在主机和服务发生状态更改时才转发事件。 it assummes ok 作为第一个状态。 它在内部使用了。

    ,sending emails emails useful spam spam spam spam critical critical critical critical critical critical critical critical critical critical send send send。

    tagged_any ( 常量 tags_t &标记)

    只有当事件包含任何给定的标记才会转发事件。

    tagged_any({"debian", "ubuntu"})>> 上面(5)>> email();
    tagged_all ( 常量 tags_t &标记)

    只有当事件包含所有给定的标记才会转发事件。

    tagged_any({"production", "london"})>> 上面(5)>> email();
    标记( const-std::string 标记)

    只有当事件包含给定的标记才会转发事件。

    tagged("production")>> 上面(5)>> email();
    smap ( 常量 smap_fn_t-fn )

    事件为 recevied,并传递到 fn作为静音参考。 你可以随意修改接收到的事件。

    下面的函数将把主机 NAME 附加到服务。

    voidhost_service(Event & e)
    {
     e.set_service(e.service() + "-" + e.host());
    };smap(host_service)>> prn("new shiny service string");
    ( const,const,const-fold_fn_t-fn )

    每次收到事件时,最后一个事件都被传递给 fn fn fn fn返回一个转发的新事件。

    ( const,const,const-fold_fn_t-fn )

    它将非重叠的Windows n 事件传递给 fn fn fn fn fn返回一个新的事件,该事件被转发到。

    ) ( const ,const-fold_fn_t-fn,const fn

    每次接收事件时, dt中的最后一个事件将传递给 fn fn fn fn返回一个新事件,该事件被转发。

    ) ( const ,const-fold_fn_t-fn,const fn

    它将接收到的事件的非重叠的Windows 传递给 窗口,该窗口返回一个新的事件,该事件将转发一个新的事件。

    稳定( const )

    仅当事件的状态与 dt 秒相同时才转发事件。 这有助于避免尖峰。

    ( size_t-n,time_t-dt )

    它只在秒时转发最大事件。

    ( time_t间隔,const-std::vector 百分比)

    它创建一个表示接收到的指标分布的库。 每秒,它将发出一个事件列表,其中包含给定的percentiles。

    相应的百分比将被添加到所发出事件的服务 NAME 中。

    // This will create a distrbution of the request_time metrics, and every// 2 seconds it will emit events containing percentils: 0th, 50th, 90th, 95th// and 100thservice("request_time")>> percentiles(2, {0.0, 0.5, 0.90, 0.95, 1});
    上( 双k ) 上的

    它以高于的指标向前事件。

    ( 双k )

    在 k 下,用公制 metric forward。

    在( 双a,双b ) 内的

    它将事件与 和b 之间的度量 forwards。

    不带( 双a,双b )的

    它将事件与非( , ) 间隔中的度量。

    比例( 双精度)

    它按的 scale事件'metric并转发它们。

    // Transform bytes in bitsservice("eth0_incoming")>> scale(8);
    ( )

    它只是转发事件。

    计数器( )

    它计算通过它的事件的数量。

    过期( )

    它转发过期的事件。

    not_expired ( )

    它转发未过期的事件。

    标记( tags_t标记)

    它向事件添加传递的标记的列表,并将它们转发到。

    tags({"processed"})>> prn("tag added")
    ( )

    它是differenciates的两个后续事件。 转发事件的度量为( metric_current - metric_previous )/( time_current - time_previous )。

    send_index ( )

    它索引receivied事件。 索引事件可以通过 web socket查询。

    这是usful从仪表板了解事件的当前状态。

    ( const-std::string 主机,常量int端口)

    它将接收到的事件转发到 Graphite 服务器,使用新的行碳TCP协议。

    这是一个基于xml的外部用户定义函数,这意味着cavalieri将与外部服务( 在本例中为 Graphite 服务器) 进行对话。

    ( const-std::string 主机,const int端口)

    它使用TCP将接收到的事件转发到cavalieri或者黎曼服务器。

    这是基于xml的外部用户定义函数,这意味着cavalieri将与外部服务( 在本例中为cavalieri或者黎曼服务器。

    电子邮件( const服务器,const,const-std::string 到) )

    它通过指定的SMTP服务器,将收到的事件与发送sender发送给收件人收件人收件人using收件人。

    这是一个内置的外部用户定义函数,这意味着cavalieri将与外部服务( 在本例中是SMTP服务器) 对话。

    pagerduty_trigger ( const-std::string-pd_key )

    它基于接收到的事件触发呼叫任务事件,并使用 pd_key 作为API密钥。 请注意,服务密钥将是事件和服务的宿主。

    这是一个内置的外部用户定义函数,意味着cavalieri将与外部服务( 在本例中为寻呼任务) 进行对话。

    pagerduty_acknowoledge ( const-std::string-pd_key )

    它基于接收到的事件确认呼叫任务事件,并使用 pd_key 作为API密钥。 请注意,服务密钥将是事件和服务的宿主。

    这是一个内置的外部用户定义函数,意味着cavalieri将与外部服务( 在本例中为寻呼任务) 进行对话。

    pagerduty_resolve ( const-std::string-pd_key )

    它基于接收的事件解析呼叫任务事件,并使用 pd_key 作为API密钥。 请注意,服务密钥将是事件和服务的宿主。

    这是一个内置的外部用户定义函数,意味着cavalieri将与外部服务( 在本例中为寻呼任务) 进行对话。

    折叠函数

    折叠函数是获取事件列表的函数,执行一些处理,比如减少和返回事件的结果。

    这些函数主要用于将事件列表转发给流函数的流函数。

    和( 常量 std::vector 事件)

    它返回一个包含事件的度量值之和的事件。

    产品( const-std::vector 事件)

    它返回一个事件,其中包含事件的度量的乘积。

    差异( const-std::vector 事件)

    它返回一个事件,其中包含事件的度量的差异。

    均值( const-std::vector 事件)

    它返回一个事件,该事件包含事件事件的度量值的平均值。

    最小( const-std::vector 事件)

    它返回一个事件,其中包含事件的最小值的值。

    最大( 常量 std::vector 事件)

    它返回一个事件,其中包含事件的最大度量值。

    计数( const-std::vector 事件)

    它返回一个事件,该事件包含接收到的事件的数量( 事件)。

    通用规则

    这些规则基于上述流函数,但是它们更高级,更固执。

    他们认为,两种状态是关键的,而非关键的。 来自这些函数的事件将它的状态设置为它们中的任何一个。

    critical_上面 ( 双精度值)

    如果度量高于值,它将状态设置为临界值。 否则,它将设置为 ok。

    critical_under ( 双精度值)

    它将状态设置为ok如果度量处于值。 否则它就会把它设定为。

    ( 双,触发器)

    它采用触发器作为函数谓词来检查事件。 它将触发器返回为 critical true 秒时,将状态设置为临界值。

    它将触发器返回 critical trigger trigger trigger false seconds秒seconds返回 critical。

    这有助于避免尖峰。

    stable_metric( /* seconds */300, p::上面(200))
    >> changed_state("ok")
    >> email();
    stable_metric ( 双 dt,predicate_t触发器,predicate_t取消)

    类似于上面的函数,但是采用额外的谓词取消它被用作将它设置为 ok ok的阈值。

    它将触发的状态设置为关键时,返回 true 超过秒。

    取消返回 critical cancel取消返回 true 秒more秒。

    这有助于避免尖峰。

    stable_metric( /* seconds */300, p::上面(200))
    >> changed_state("ok")
    >> email();
    agg_stable_metric ( 双 dt,fold_fn_t-fold_fn,predicate_t触发器,predicate_t取消)

    这里函数聚合使用 fold_fn (。查看折叠函数) 接收的事件的度量。 结果是通过使用 dt 触发器和取消传递给一个stable_metric流。

    让我们看看一个例子。假设我们在伦敦数据中心有许多网络服务器。 这些服务器报告一个名为 failed_requests_rate的度量。 如果你希望创建一个 metric,那么你可以在 seconds秒的时间内创建一个警报,并触发警报。

    service("failed_requests_rate")
    >> tagged("datacenter::london")
    >> agg_stable_metric(/* secs */300, sum, p::上面(200), p::under(50))
    >> changed_state("ok")
    >> email();
    max_critical_hosts ( size_t-n )

    这个函数将事件的状态设置为关键,当它接收到超过个重要事件时,。

    在下面的例子中,当超过 20台服务器报告 Puppet 故障时,我们触发一个警报。

    service("puppet")
    >> tagged("datacenter::paris")
    >> max_critial_hosts(20)
    >> changed_state()
    >> set_host("datacenter::paris")
    >> set_service("too many puppet failures")
    >> email();

    谓词函数

    这些函数用于筛选事件。 它的主要目的是评估事件并返回 true 或者 false 基于所检查的内容。

    有两种类型的谓词函数。 返回 predicate_t,它可以用作 where() split split split split的参数。 那些返回的bool 可以返回构建自己的函数,或者在自己的流函数中。

    predicate_t-上面_eq ( 常量双精度值)

    检查事件度量是否为 GREATER,或者等于值。

    上面的 predicate_t ( const double值)

    检查事件度量是否为 GREATER 值,而非值。

    predicate_t-under_eq ( 常量双精度值)

    检查事件度量是否小于或者等于值。

    在( const-double ) 下的 predicate_t

    检查事件度量是否小于值。

    predicate_t状态( const-std::string 状态)

    检查事件状态是否等于状态。

    predicate_t服务( const-std::string 服务)

    检查事件服务是否等于服务。

    匹配( 常量键,const-std::string 值)

    在事件中检查字段的键是否等于值。

    :predicate_t ( const-std::string:: vectorstd: 字符串值)

    在事件中检查字段的键是否等于任何值。

    predicate_t ( const-std::string 键,const-std::string 正规表达式 )

    检查字段的键是否在事件 MATCHES 中,在 正规表达式 中的正则表达式。

    正规表达式 是一个包含有效的ECMAScript 正则表达式的字符串。

    :predicate_t ( const-std::string 键,const:: vectorstd:: 字符串 regex

    检查事件 MATCHES 中的字段键是否在正则表达式中的任何正则表达式。

    ( const-std::string-key,const-std::string,像)

    检查事件的关键字是否在事件 MATCHES 中,如使用'%'来搜索模式的字符串。

    :predicate_t likes ( const-std::string-key,const-std:: vectorstd: string类型)

    检查是否在事件 MATCHES 中双击了字段的键( 例如),如字符串。

    predicate_t-default_true ( )

    这里函数总是返回 true。

    布尔 tagged_any ( e_t事件,const tags_t&标记)

    检查是否有任何标记出现在事件。

    布尔 tagged_all ( e_t事件,const tags_t&标记)

    检查所有标签是否都存在于事件。

    过期( e_t事件)

    检查事件是否过期。

    布尔 上面_eq ( e_t事件,const double值)

    检查事件的度量是否大于或者等于值。

    上面的 ( e_t事件,const double值)

    检查事件中的度量是否为 GREATER,而非值。

    布尔 under_eq ( e_t事件,const double值)

    检查事件中的度量是否小于或者等于的值。

    在( e_t事件,const double值) 下的

    检查事件中的度量是否小于值。

    bool匹配( e_t事件,常量 std::string 键,const-std::string 值)

    检查字段是否为键中的字段值是否等于值。

    ( e_t事件,const-std::string 键,const-std::string 正规表达式 )。

    检查 field event是否在事件中的字段 MATCHES 正规表达式。

    布尔 match_like ( e_t事件,const-std::string 键,const-std::string )

    检查字段中的字段是否与使用'%'的MATCHES 类似,例如使用的字符串,使用搜索模式。

    事件类

    这是在Cavalieri中广泛使用的事件类。 它基本上是 generataed 黎曼protobuf类的包装,它添加了一些方便的函数。

    下面是这个的函数成员的列表:

    • 事件( )

    • 事件( const riemann::Event &事件)

    • 事件( const事件 & ) = 默认值

    • 事件 copy() 常量

    • riemann::Event riemann_event() 常量

    • std::string host() 常量

    • 事件 & set_host ( const std::string 主机)

    • bool has_host() 常量

    • 事件 & clear_host ( )

    • std::string service() 常量

    • 事件 & set_service ( const std::string 服务)

    • bool has_service() 常量

    • 事件 & clear_service ( )

    • std::string state() 常量

    • 事件 & set_state ( 常量 std::string 状态)

    • bool has_state() 常量

    • 事件 & clear_state ( )

    • std::string description() 常量

    • 事件 & set_description ( const std::string 描述)

    • bool has_description() 常量

    • 事件 & clear_description ( )

    • int64_t time() 常量

    • 事件 & set_time ( 常量int64_t时间)

    • bool has_time() 常量

    • 事件 & clear_time ( )

    • float ttl() 常量

    • 事件 & set_ttl ( 常量浮点 ttl )

    • bool has_ttl() 常量

    • 事件 & clear_ttl ( )

    • double metric() 常量

    • 事件 & set_metric ( const双度量)

    • bool has_metric() 常量

    • 事件 & clear_metric ( )

    • std::string metric_to_str() 常量

    • float metric_f() 常量

    • 事件 & set_metric_f ( 常量浮点度量)

    • bool has_metric_f() 常量

    • 事件 & clear_metric_f ( )

    • float metric_d() 常量

    • 事件 & set_metric_d ( const双度量)

    • bool has_metric_d() 常量

    • 事件 & clear_metric_d ( )

    • int64_t metric_sint64() 常量

    • 事件 & set_metric_sint64 ( 常量int64_t度量)

    • bool has_metric_sint64() 常量

    • 事件 & clear_metric_sint64 ( )

    • std::string value_to_str ( const std::string 字段) 常量

    • bool has_field_set ( const std::string 字段) 常量

    • std::string json_str() 常量

    • bool has_tag ( const std::string 标记) 常量

    • 事件 & add_tag ( const std::string 标记)

    • 事件 & clear_tags ( )

    • bool has_attr ( const std::string 属性) 常量

    • std::string ( const std::string 属性) 常量

    • 事件 & set_attr ( 常量 std::string 属性,const std::string 值)

    • 事件 & clear_attrs ( )

    一些 typedef

    仪表板

    你可以使用标准 riemann.io dahsboard 查询和可视化索引的状态。


    tool  str  PROC  EVE  event  监视器  
    相关文章