Rule Engine for Flexible Telemetry Data Processing
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing HTTP telemetry data processing tools lack flexibility, requiring software upgrades to add new capabilities, as they are based on fixed function implementations that cannot be changed without recompiling the code.
Innovation Solution
A flexible rule-engine based approach is introduced, where new HTTP telemetry data processing functions can be implemented by writing rules, allowing for different input, processing, and output without modifying the code or recompiling, thereby adapting to various scenarios.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Adaptability or versatility
If fixed function implementations are used for telemetry data processing, then the system structure is simple and stable, but the adaptability and flexibility are poor, requiring software upgrades to add new capabilities
Solution Approach 1:
The patent implements a dynamic rule engine that allows processing logic to be changed at runtime through rule definitions rather than requiring code modifications. The rule engine can load, unload, and execute different rules dynamically, enabling the system to adapt to new telemetry data processing requirements without software upgrades. This transforms the static fixed-function architecture into a dynamic configurable system.
Solution Approach 2:
The patent creates a universal rule engine framework that can handle multiple types of telemetry data processing tasks through a single configurable component. The engine uses a standardized rule structure with filters, conditions, and actions that can be applied to various telemetry data types and processing scenarios, replacing multiple specialized fixed functions with one multi-functional engine.
2Ease of operation
If fixed function implementations are used, then the code is stable and maintainable, but adding new processing capabilities requires recompiling code and software upgrades
Solution Approach 1:
The patent pre-defines a comprehensive rule structure including filters, conditions, and actions that can accommodate various telemetry data processing scenarios. By establishing this flexible framework in advance with configurable components, the system enables rapid deployment of new capabilities through rule configuration rather than code development, eliminating the time-consuming software upgrade process.
Solution Approach 2:
The patent enables changing system behavior by modifying rule parameters and configurations rather than altering the underlying code. The rule engine accepts configurable parameters such as filter criteria, condition thresholds, and action definitions that can be adjusted at runtime to implement new processing capabilities, transforming the system from code-modification-based to parameter-based configuration.
3Adaptability or versatility
If a flexible rule-engine approach is adopted, then adaptability and flexibility improve, but the device complexity and rule management overhead increase
Solution Approach 1:
The patent segments the rule engine into distinct modular components: filters for data preprocessing, conditions for logic evaluation, and actions for output generation. Each component is independently configurable and can be combined in various sequences to create different processing pipelines. This segmentation reduces overall complexity by making the system more organized and manageable despite its flexibility.
Solution Approach 2:
The patent introduces an intermediary rule engine layer that sits between the telemetry data input and the processing logic. This mediator translates high-level rule definitions into executable processing operations, shielding users from the underlying complexity while providing flexible configuration capabilities. The intermediary manages the complexity internally through standardized interfaces and execution mechanisms.
Data Source
AI summary
Embodiments determine event, e.g., performance degradation, security breach, etc., occurrence based on telemetry data. An embodiment receives telemetry data, e.g., data based on an HTTP transaction, and a rule associated with the telemetry data. The rule defines one or more filters for processing the telemetry data. In turn, a rule engine is modified in accordance with the received rule. The received telemetry data is processed with the modified rule engine to determine event occurrence.