Dynamic Debug Log Enabler for Protection Failure Jobs
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Debug logging is typically disabled due to space constraints, making it difficult to troubleshoot and debug operations as issues are often non-reproducible, requiring users to re-run scenarios to gather necessary information.
Innovation Solution
A method and computer-readable code that dynamically store debug logs in a cache during operations, with logs being written to persistent storage upon failure and deleted periodically to maintain cache size, allowing for efficient troubleshooting without re-running scenarios.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Loss of information
If debug logging is enabled during operations, then troubleshooting and debugging information is available, but storage space is consumed excessively
Solution Approach 1:
The patent segments the operation into multiple portions and segments the debug log storage into a cache portion and persistent storage portion. Debug logs are collected in segments during different portions of the operation and stored in the cache, with only necessary segments written to persistent storage upon failure, thereby reducing overall storage consumption while maintaining debugging capability.
Solution Approach 2:
The patent implements dynamic debug logging where the logging behavior adapts based on operation status. The system dynamically switches between collecting logs in cache during normal operation and writing to persistent storage only when failure occurs, making the storage approach flexible and responsive to actual debugging needs rather than statically enabled or disabled.
2Quantity of substance
If debug logging is disabled to save space, then storage is conserved, but troubleshooting becomes difficult as issues are non-reproducible
Solution Approach 1:
The patent performs preliminary action by proactively collecting and storing debug logs in the cache during normal operation before any failure occurs. This ensures that debugging information is already available when needed, eliminating the need to re-run operations to reproduce issues and ensuring reliable troubleshooting without requiring persistent storage for all logs.
Solution Approach 2:
The patent introduces a cache as an intermediary storage layer between the operation and persistent storage. This cache temporarily holds debug logs during operation execution, allowing troubleshooting information to be preserved and analyzed without requiring long-term persistent storage, thus bridging the gap between limited storage and reliable debugging.
3Loss of information
If debug logs are stored continuously, then complete troubleshooting information is available, but cache size grows excessively large
Solution Approach 1:
The patent applies discarding and recovering by periodically removing older or unnecessary debug logs from the cache according to a predefined procedure. This prevents cache size from growing excessively while ensuring that relevant debugging information is retained and can be recovered if needed for troubleshooting current or recent failures.
4Loss of information
If users re-run scenarios to gather debugging information, then complete log data is obtained, but time is wasted and productivity decreases
Solution Approach 1:
The patent ensures continuity of useful action by continuously collecting and storing debug logs in the cache throughout the operation without interruption. This continuous logging ensures that debugging information is always available when needed, eliminating the need to stop and re-run operations to gather log data, thus saving time and maintaining productivity.
Data Source
AI summary
The present invention provides a system, computer readable code and method for dynamically performing debugging. The system, code, and method store debugging logs throughout an operation. At predetermined points the logs are stored to a cache. Older and/or unnecessary logs are periodically deleted from the cache to ensure that the cache does not grow to be larger than a predetermined size. This avoids the need to re-run a scenario after an error occurs in order to produce troubleshooting/debugging information.


