Object History Tracking With Selective Debug Event Capture
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Conventional software debugging methods generate massive amounts of tracing information that overwhelm system resources and fail to provide adequate object history in object-oriented programming, making troubleshooting inefficient and resource-intensive.
Innovation Solution
Implement a tracking function that records specific events in the history of a target object by linking tracked functions to a tracking class, storing tracking data within the object, and enabling customizable tracking levels to reduce resource usage.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Loss of information
If conventional tracing information is captured and stored during program execution, then debugging information is provided, but system memory and processing resources are overwhelmed
Solution Approach 1:
The patent extracts only the essential debugging information needed for effective troubleshooting by implementing selective tracking of specific object attributes and events. Instead of capturing all possible tracing data, the system identifies and records only relevant state changes, method calls, and object interactions that contribute to understanding the bug, thereby reducing information volume while maintaining debugging effectiveness.
Solution Approach 2:
The patent segments the tracing information by object type, attribute, and event category, allowing selective recording of different data elements. This segmentation enables the system to track only the specific objects and attributes relevant to the debugging task at hand, rather than uniformly tracking all program elements, thus reducing overall information volume while preserving critical debugging data.
2Reliability
If comprehensive tracing information is stored in trace files, then complete execution history is available, but processing and memory resources are consumed affecting system performance
Solution Approach 1:
The patent applies local quality by implementing variable tracking depth and detail based on the specific debugging needs of different objects and code regions. Critical objects receive detailed tracking while less important objects receive minimal or no tracking, allowing the system to maintain high debugging accuracy for essential components while reducing overall resource consumption to preserve system performance.
Solution Approach 2:
The patent implements partial action by recording only the specific tracing events necessary for debugging rather than capturing the complete execution history. The system selectively enables tracking for particular objects, methods, or time periods based on the debugging requirements, thereby achieving sufficient debugging reliability without the performance penalty of comprehensive tracing.
3Loss of information
If all tracing information is recorded and stored, then complete program state is captured, but irrelevant information increases review time and resource consumption
Solution Approach 1:
The patent applies preliminary action by pre-identifying and configuring which objects, attributes, and events should be tracked before debugging begins. This preliminary configuration allows the system to automatically filter and record only the relevant information during execution, eliminating the need to review large volumes of irrelevant data later and significantly reducing the time required to analyze tracing information.
4Loss of information
If detailed object history tracking is implemented, then object state changes are revealed, but memory and processing resources are consumed
Solution Approach 1:
The patent implements parameter changes by dynamically adjusting the level of tracking detail based on object importance, state change frequency, and debugging priorities. The system can modify tracking parameters such as sampling rate, attribute selection, and event filtering in real-time, allowing detailed object history to be recorded for critical objects while using coarser-grained tracking for less important objects, thereby reducing overall data volume while maintaining essential object history information.
Data Source
AI summary
Example methods and systems are directed to the enabling of object history tracking in an object-oriented programming environment. According to some examples, a tracking class includes a tracking function and a tracked class includes a tracked function. A system receives user input to link the tracked function to the tracking function. Executable code is executed to create a target object of the tracked class and to execute the tracked function with respect to the target object. Execution of the tracked function triggers the tracking function to obtain tracking data relating to the target object. The tracking data is stored as part of the target object. According to some examples, the system receives an indication of an error that occurred during execution of the executable code, retrieves the tracking data from the target object, and causes presentation of the tracking data at a user device.