RuleGo/rulego

# RuleGo English| [中文](README_ZH.md) <img src="doc/imgs/logo.png" width="100"> `RuleGo` is a lightweight, high-performance, embedded rule engine based on `Go` language. It is also a flexible and highly customizable event processing framework. It can aggregate, distribute, filter, transform, enrich and execute various actions on input messages. This project is largely inspired by [thingsboard](https://github.com/thingsboard/thingsboard) . ## Features * Development language: Go 1.18 * Lightweight: No external middleware dependencies, can efficiently process and link data on low-cost devices, suitable for IoT edge computing. * High performance: Thanks to the high-performance characteristics of `Go`, in addition, `RuleGo` adopts technologies such as coroutine pool and object pool. For 10W data processing `JS script filtering->JS script data processing->HTTP push`, the average time is 9 seconds. * Embedded: Support embedding `RuleGo` into existing projects, non-intrusively utilizing its features. * Componentized: All business logic is componentized and can be flexibly configured and reused. * Rule chain: You can flexibly combine and reuse different components to achieve highly customizable and scalable business processes. * Process orchestration: Support dynamic orchestration of rule chains, you can encapsulate your business into `RuleGo` components, and then achieve your highly changing business needs by building blocks. * Easy to extend: Provide rich and flexible extension interfaces and hooks, such as: custom components, component registration management, rule chain DSL parser, coroutine pool, rule node message inflow/outflow callback, rule chain processing end callback. * Dynamic loading: Support dynamic loading of components and extension components through `Go plugin`. * Built-in common components: `Message type Switch`,`JavaScript Switch`,`JavaScript filter`,`JavaScript converter`,`HTTP push`,`MQTT push`,`Send email`,`Log record` and other components. You can extend other components by yourself. * Context isolation mechanism: Reliable context isolation mechanism, no need to worry about data streaming in high concurrency situations. ## Use Cases `RuleGo` is a rule engine based on orchestration, which is best at decoupling your system. - If your system is complex and bloated with code - If your business scenario is highly customized or frequently changed - Or you need an end-to-end IoT solution - Or you need to process data from heterogeneous systems centrally - Or you want to try hot deployment in `Go` language... Then `RuleGo` framework will be a very good solution. #### Typical use cases * **Edge computing:** For example: You can deploy `RuleGo` on the edge server, preprocess, filter, aggregate or calculate the data before reporting it to the cloud. The data processing rules and distribution rules can be dynamically configured and modified through the rule chain without restarting the system. * **Internet of Things:** For example: Collect device data reporting, and after the rule judgment of the rule chain, trigger one or more actions, such as: send email, send alarm, and link with other devices or systems. * **Data distribution:** For example: You can distribute data to different systems according to different message types, such as HTTP, MQTT or gRPC. * **Application integration:** For example: kafka, message queue, third-party system integration. * **Data processing from heterogeneous systems:** For example: Receive data from different data sources (such as MQTT, HTTP, etc.), and then filter, format conversion, and then distribute to databases, business systems or dashboards. * **Highly customized business:** For example: Decouple highly customized or frequently changed business and hand it over to `RuleGo` rule chain for management. Business requirements change without restarting the main program. * **Complex business orchestration:** For example: Encapsulate the business into custom components, and use `RuleGo` to orchestrate and drive these custom components, and support dynamic adjustment. * **Microservice orchestration:** For example: Use `RuleGo` to orchestrate and drive microservices, or dynamically call third-party services to process business and return results. * **Business code and business logic decoupling:** For example: User points calculation system, risk control system. * **Flexible configuration and highly customized event processing framework:** For example: Asynchronously or synchronously process different message types. ## Installation Use the `go get` command to install `RuleGo`: ```bash go get github.com/rulego/rulego ``` ## Usage Use Json format to define the rule chain DSL: The following example defines 3 rule nodes, and the rule chain logic is as follows: (For more examples, refer to [testcases/](testcases)) <img src="doc/imgs/rulechain/img_1.png" style="height:50%;width:80%;"> ```json { "ruleChain": { "name": "Test rule chain", "root": true, "debugMode": false }, "metadata": { "nodes": [ { "id": "s1", "type": "jsFilter", "name": "Filtering Data", "debugMode": true, "configuration": { "jsScript": "return msg!='bb';" } }, { "id": "s2", "type": "jsTransform", "name": "Transform Data", "debugMode": true, "configuration": { "jsScript": "metadata['test']='test02';\n metadata['index']=50;\n msgType='TEST_MSG_TYPE2';\n var msg2=JSON.parse(msg);\n msg2['aa']=66;\n return {'msg':msg2,'metadata':metadata,'msgType':msgType};" } }, { "id": "s3", "type": "restApiCall", "name": "Call Rest Api Push Data", "debugMode": true, "configuration": { "restEndpointUrlPattern": "http://192.168.216.21:9099/api/socket/msg", "requestMethod": "POST", "maxParallelRequestsCount": 200 } } ], "connections": [ { "fromId": "s1", "toId": "s2", "type": "True" }, { "fromId": "s2", "toId": "s3", "type": "Success" } ], "ruleChainConnections": null } } ``` Description: - `ruleChain`: The root object of the rule chain definition, which contains the following fields: - `name`: The name of the rule chain, which can be any string. - `root`: A boolean value indicating whether this rule chain is the root rule chain or a sub-rule chain. Only one root rule chain is allowed per rule engine instance. - `debugMode`: A boolean value indicating whether this rule chain is in debug mode or not. If true, the debug callback function will be triggered when the rule chain processes messages. - `metadata`: An object that contains the information of the nodes and connections in the rule chain, which has the following fields: - `nodes`: An array of objects, each representing a rule node in the rule chain. Each node object has the following fields: - `id`: A unique identifier for the node, which can be any string. - `type`: The type of the node, which determines the logic and behavior of the node. It should match one of the registered node types in the rule engine. - `name`: The name of the node, which can be any string. - `debugMode`: A boolean value indicating whether this node is in debug mode or not. If true, the debug callback function will be triggered when the node processes messages. - `configuration`: An object that contains the configuration parameters for the node, which vary depending on the node type. For example, a JS filter node may have a `jsScript` field that defines the filtering logic, while a REST API call node may have a `restEndpointUrlPattern` field that defines the URL to call. - `connections`: An array of objects, each repr