Configurable Rules Engine for Dynamic Software Observability
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
The existing approach of hard-coding a client application's observability behavior prior to its release limits the ability of software providers to modify this behavior in a timely or efficient manner, leading to time-consuming and costly processes for updating log levels or tailoring observability based on runtime session specifics.
Innovation Solution
A client application embedded with a configurable rules engine that can execute rules related to observability behavior, where each rule comprises a trigger event and a set of actions. This allows for dynamic changes to observability behavior during runtime without requiring a new version of the client application.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Adaptability or versatility
If observability behavior is hard-coded prior to release, then the application structure is simple and reliable, but the ability to modify behavior in a timely manner is limited
Solution Approach 1:
The patent implements a configurable rules engine that allows observability behavior to be dynamically changed during runtime without requiring application updates. Rules with trigger events and actions enable the system to adapt its observability characteristics (such as logging levels and data collection) based on runtime conditions, transforming the static hard-coded approach into a dynamic configurable system.
Solution Approach 2:
The patent changes the parameters of observability behavior through configurable rules that modify logging levels, data collection frequency, and other observability parameters at runtime. This allows the system to adjust its observability characteristics without changing the underlying application code structure, resolving the contradiction between adaptability and structural simplicity.
2Productivity
If traditional release cycles are used to update observability behavior, then the application structure is simple, but the process is time-consuming and costly
Solution Approach 1:
The configurable rules engine enables real-time modification of observability behavior during application runtime, eliminating the need for traditional release cycles. Administrators can update rules and immediately see changes reflected in the application's observability characteristics, dramatically increasing productivity and eliminating time losses associated with compilation, testing, and deployment processes.
Solution Approach 2:
The rules engine acts as an intermediary layer between the application code and observability configurations. This intermediary allows observability parameters to be modified without changing the application code itself, enabling rapid updates without triggering full release cycles and significantly reducing the time and cost of modifying observability behavior.
3Adaptability or versatility
If observability behavior is customized for different runtime conditions, then the observability is tailored and useful, but the configuration complexity increases
Solution Approach 1:
The patent segments observability configuration into discrete, manageable rules, each with specific trigger events and actions. This segmentation allows complex observability behavior to be built from simple, independent rule units that can be configured and managed separately, reducing overall configuration complexity while maintaining high adaptability for different runtime conditions.
Solution Approach 2:
The configurable rules engine applies different observability settings locally to specific runtime conditions rather than requiring global configuration changes. Each rule is tailored to specific trigger events (such as error conditions, user actions, or performance thresholds) and applies appropriate observability actions only when those conditions are met, enabling targeted customization without overwhelming configuration complexity.
Data Source
AI summary
A computing system configured to (i) present a user interface (UI) for creating a rule related to observability behavior of a software application, (ii) receive a first set of user inputs for creating a first UI element representing a trigger-event condition to be added to the rule, (iii) create the first UI element, (iv) receive a second set of user inputs for creating a second UI element representing an action to be added to the rule, (v) create the second UI element, and (vi) send, to a computing platform associated with a software provider of the software application, a request to deploy the rule and thereby cause the computing platform to deploy the rule to a set of computing devices installed with the software application, wherein the rule is defined to include the trigger-event condition represented by the first UI element and the action represented by the second UI element.