
# 事件操作函数
本文介绍事件操作函数的语法规则，包括参数解释、函数示例等。
#### 函数列表
| **类型** | **函数**                                                                                                                                          | **说明**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
|:---|:---|:---|
| 事件操作   | [e_drop]             | 根据条件判断是否丢弃日志，支持和其他函数组合使用。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| 事件操作   | [e_keep]             | 根据条件判断是否保留日志，支持和其他函数组合使用。 e_keep函数和e_drop函数都会丢弃日志。e_keep函数在不满足条件时丢弃，而e_drop函数则是在满足条件时丢弃。 ``` # 以下4个加工规则等价 e_if_else(e_search("f1==v1"), e_keep(), e_drop()) e_if_else(e_search("not f1==v1"), e_drop()) e_keep(e_search("f1==v1")) e_drop(e_search("not f1==v1")) # 以下加工规则无意义 e_if(e_search("..."), e_keep()) e_keep() ```                                                                                                                                                                                                                                                                                                                                                           |
| 事件分裂   | [e_split]           | 基于日志字段的值分裂出多条日志，并且支持通过JMES提取字段后再进行分裂。支持和其他函数组合使用。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| 输出事件   | [e_output、e_coutput] | 输出日志到指定的日志流别名中（日志流别名在创建加工任务时配置目标日志流时指定），并可配置输出时的tag信息。 - e_output：执行到e_output函数时，输出日志到指定的日志流中，且对应的日志不再执行后面的加工规则。支持和其他函数组合使用。  - e_coutput：执行到e_coutput函数时，输出日志到指定的日志流中，且对应的日志继续执行后面的加工规则。支持和其他函数组合使用。   |
| 输出事件   | [e_custom_lts_log_time]                                                         | 自定义生成新的日志时间。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
   
 #### e_drop
根据条件判断是否丢弃日志。
- **函数格式**
  ```
  e_drop(condition=true)
  ```
  支持固定标识DROP，等价于e_drop()。
  
- **参数说明**
  
  | **参数名称**  | **参数类型** | **是否必填** |          **说明**          |
  |---|---|---|---|
  | condition | Bool     | 否        | 默认为true，一般传递一个条件判断函数的结果。 |
     
  
- **返回结果**
  满足条件则丢弃日志并返回None，否则返回原日志。
  
- **函数示例**
  1. 示例1：当__program__字段的值为access时丢弃日志，否则保留该日志。
     - 测试数据
       ```
       [
       {
        "__program__": "access", 
        "age":  18,
        "content":  123,
        "name":  "maki" 
       },
       {
        "__program__": "error", 
        "age":  18,
        "content":  123,
        "name":  "maki"
       }
       ]
       ```
       
     
     - 加工规则
       ```
       e_if(e_search("__program__==access"), e_drop())
       ```
       
     
     - 加工结果 丢弃__program__字段值为access的日志，保留__program__字段的值为error的日志。
       ```
       __program__: error 
       age:  18
       content:  123
       name:  maki
       ```
       
      
  
  2. 示例2：条件判断结果为true，丢弃日志。
     - 测试数据
       ```
       {
        "k1":"v1" ,
        "k2": "v2",
        "k3": "k1"
       }
       ```
       
     
     - 加工规则
       ```
       e_drop(e_search("k1==v1"))
       ```
       
     
     - 加工结果 因为k1==v1条件为true，因此丢弃该日志。
       
      
  
  3. 示例3：条件判断结果为false，保留日志。
     - 测试数据
       ```
       {
        "k1":"v1" ,
        "k2": "v2",
        "k3": "k1"
       }
       ```
       
     
     - 加工规则
       ```
       e_drop(e_search("not k1==v1"))
       ```
       
     
     - 加工结果
       ```
       k1: v1 
       k2: v2 
       k3: k1
       ```
       
      
  
  4. 示例4：不设置判断条件时，使用默认值true，丢弃日志。
     - 测试数据
       ```
       {
        "k1":"v1" ,
        "k2": "v2",
        "k3": "k1"
       }
       ```
       
     
     - 加工规则
       ```
       e_drop()
       ```
       
     
     - 加工结果 丢弃日志。
       
      
   
- **更多参考**
  支持和其他函数组合使用。
  
 
 #### e_keep
据条件判断是否保留日志。
- **函数格式**
  ```
  e_keep(condition=true)
  ```
  支持固定标识KEEP，等价于e_keep()。
  
- **参数说明**
  
  | **参数名称**  | **参数类型** | **是否必填** |          **说明**          |
  |---|---|---|---|
  | condition | Bool     | 否        | 默认为true，一般传递一个条件判断函数的结果。 |
     
  
- **返回结果**
  满足条件则返回原日志，不满足时丢弃日志。
  
- **函数示例**
  1. 示例1：当__program__字段的值是access的时候保留日志，否则丢弃日志。
     - 测试数据
       ```
       [
       {
       "__program__": "access" ,
       "age":  18,
       "content":  123,
       "name": "maki" 
       },
       {
       "__program__": "error" ,
       "age":  18,
       "content":  123,
       "name":  "maki"
       }
       ]
       ```
       
     
     - 加工规则
       ```
       e_keep(e_search("__program__==access"))
       #等价于
       e_if(e_search("not __program__==access"), e_drop())  
       #等价于
       e_if_else(e_search("__program__==access"), e_keep(), e_drop())
       ```
       
     
     - 加工结果 保留__program__字段值为access的日志。
       ```
       __program__: access 
       age:  18
       content:  123
       name:  maki
       ```
       
      
  
  2. 示例2：条件判断结果为true，保留日志。
     - 测试数据
       ```
       {
        "k1":"v1" ,
        "k2": "v2",
        "k3": "k1"
       }
       ```
       
     
     - 加工规则
       ```
       e_keep(e_search("k1==v1"))
       ```
       
     
     - 加工结果
       ```
       k1: v1 
       k2: v2 
       k3: k1
       ```
       
      
  
  3. 示例3：条件判断结果为false，丢弃日志。
     - 测试数据
       ```
       {
        "k1":"v1" ,
        "k2": "v2",
        "k3": "k1"
       }
       ```
       
     
     - 加工规则
       ```
       e_keep(e_search("not k1==v1"))
       ```
       
     
     - 加工结果：丢弃日志。
      
  
  4. 示例4：判断条件为false。
     - 测试数据
       ```
       {
        "k1":"v1" ,
        "k2": "v2",
        "k3": "k1"
       }
       ```
       
     
     - 加工规则
       ```
       e_keep(false)
       ```
       
     
     - 加工结果：丢弃日志。
      
   
- **更多参考**
  支持和其他函数组合使用。
  
 
 #### e_split
基于日志字段的值分裂出多条日志，并且支持通过JMES提取字段后再进行分裂。
- **函数格式**
  ```
  e_split(字段名, sep=',', quote='"', lstrip=true, jmes=None, output=None)
  ```
  分裂规则：
  - 如果配置了jmes参数，则将日志字段的值转化为JSON列表，并使用JMES提取值作为下一步的值。如果没有配置jmes参数，则将字段的值直接作为下一步的值。
  
  - 如果上一步的值是一个列表或JSON列表格式的字符串，则按照此列表分裂并结束处理。否则使用sep、quote或lstrip将上一步的值进行CSV解析，根据解析后的多个值进行分裂并结束处理。
   
- **参数说明**
  
  | **参数名称** | **参数类型** | **是否必填** |               **说明**                |
  |---|---|---|---|
  | 字段名      | String   | 是        | 需要分裂的字段名。                           |
  | sep      | String   | 否        | 用于分隔多个值的分隔符。                        |
  | quote    | String   | 否        | 用于引用多个值的配对类字符的引用符。                  |
  | lstrip   | String   | 否        | 是否将值左边的空格去掉，默认为true。                |
  | jmes     | String   | 否        | 将字段值转化为JSON对象，并使用JMES提取特定值，再进行分裂操作。 |
  | output   | String   | 否        | 设置一个新的字段名，默认覆盖旧字段名。                 |
     
  
- **返回结果**
  返回日志列表，列表中字段的值都是源列表中的值。
  
- **函数示例**
  - 测试数据
    ```
    {
    "__topic__": "",
    "age": 18,
    "content": 123,
    "name": "maki"
    }
    ```
    
  
  - 加工规则
    ```
    e_set("__topic__", "V_SENT,V_RECV,A_SENT,A_RECV")
    e_split("__topic__")
    ```
    
  
  - 加工结果
    ```
    [
    {
        "__topic__": "V_SENT",
        "name": "maki",
        "age": 18,
        "content": 123
    },
    {
        "__topic__": "V_RECV",
        "name": "maki",
        "age": 18,
        "content": 123
    },
    {
        "__topic__": "A_SENT",
        "name": "maki",
        "age": 18,
        "content": 123
    },
    {
        "__topic__": "A_RECV",
        "name": "maki",
        "age": 18,
        "content": 123
    }
    ]
    ```
    
   
- **更多参考**
  支持和其他函数组合使用。
  
 
 #### e_output、e_coutput
输出日志到指定的日志流中，并可配置输出时tag信息。
- **函数格式**
  ```
  e_output(logsteam,  tags=None)
  e_coutput(logstream, tags=None)
  ```
  预览时不会输出日志到目标日志流中，而是输出到页面，供您调试。
  - e_output：输出日志到指定的日志流中，且对应的日志不再执行后面的加工规则。
  
  - e_coutput：输出日志到指定的日志流中，且对应的日志继续执行后面的加工规则。
   
- **参数说明**
  
  | **参数名称**  | **参数类型** | **是否必填** |               **说明**               |
  |---|---|---|---|
  | logstream | String   | 否        | 需要输出日志流别名，日志流别名在创建加工任务时配置目标日志流时指定。 |
  | tags      | Dict     | 否        | 为日志设置新的标签，以字典格式传入。                 |
     
  
- **函数示例**
  1. 示例1：若k2字段满足输入的正则表达式，则将日志输出到target2日志流中。
     - 测试数据
       ```
       {
       "k1": "v1", 
       "k2":"v2",
       "x1":"v3" ,
       "x5": "v4"
       }
       ```
       
     
     - 加工规则 此处e_drop()函数的作用是把e_if()函数过滤掉的数据做删除处理。如果不添加该函数，则被过滤的数据被投递到默认的存储目标中。创建任务时配置的第一条目标日志流为默认目标。
       ```
       e_if(e_match("k2", r"\w+"), e_output("target2"))
       e_drop()
       ```
       
     
     - 加工结果
       ```
       {
           "k1": "v1",
           "k2": "v2",
           "x1": "v3",
           "x5": "v4"
       }
       ```
       在结果预览处可以看到目标日志流别名变成了target2。
       
      
  
  2. 示例2：若k2字段满足输入的正则表达式，则将日志输出到target2日志流中，并设置标签字段。
     - 测试数据
       ```
       {
       "k1": "v1", 
       "k2":"v2",
       "x1":"v3" ,
       "x5": "v4"
       }
       ```
       
     
     - 加工规则
       ```
       e_if(e_match("k2", r"\w+"), e_output("target2", tags={"topic": "topic1"}))
       e_drop()
       ```
       
     
     - 加工结果
       ```
       {
           "k1": "v1",
           "__tag__": {
               "topic": "topic1"
           },
           "k2": "v2",
           "x1": "v3",
           "x5": "v4"
       }
       ```
       在结果预览处可以看到目标日志流别名变成了target2。
       
      
   
- **更多参考**
  支持和其他函数组合使用。
  
 
 #### e_custom_lts_log_time
调用e_custom_lts_log_time函数自定义生成新的日志时间。
- **函数格式**
  ```
  e_custom_lts_log_time(time, is_milliseconds=True)
  ```
  
- **参数说明**
  
  |    **参数名称**     |  **参数类型**   | **是否必填** |                                                                                                                                                                                                      **说明**                                                                                                                                                                                                      |
  |---|---|---|---|
  | time            | String/数值类型 | 是        | UTC时间戳类型，单位是秒或毫秒，例如1656560437000，默认是毫秒值。                                                                                                                                                                                                                                                                                                                                                                         |
  | is_milliseconds | Bool        | 否        | 是否为毫秒值。 - 默认为true，代表是毫秒值。  - 填写为false，代表是秒值。   |
     
  
- **返回结果**
  无。
  
- **函数示例**
  1. 示例1：
     - 测试数据
       ```
       {
         "time": 1656560437000
       }
       ```
       
     
     - 加工规则
       ```
       e_custom_lts_log_time(v("time"))
       ```
       
     
     - 加工结果
       ```
       {
         "time": 1656560437000,
         "_customLogTime_": 1656560437000
       }
       ```
       
      
  
  2. 示例2：
     - 测试数据
       ```
       {
         "time": 1656560437
       }
       ```
       
     
     - 加工规则
       ```
       e_custom_lts_log_time(v("time"), false)
       ```
       
     
     - 加工结果
       ```
       {
         "time": 1656560437,
         "_customLogTime_": 1656560437000
       }
       ```
       
      
   
- **更多参考**
  支持和其他函数组合使用。
  
 
