Log Analysis Debugging via DWARF Mapping
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Debugging in a real production environment is inefficient due to the impracticality of running a debugger on client computing devices without source code, especially when large log files exceed 100 Mb, making bug identification and elimination processes inefficient or impossible.
Innovation Solution
A system and method that simulates debugging by mapping debug info and log data with current program execution addresses, allowing for variable type and stack frames views, including breakpoints, without physically executing the software program, using a log analysis debugging program that receives and loads log files, updates DWARF data structures, and identifies calling addresses to unwind stack frames.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Measurement precision
If a debugger is run on the real production environment to debug computer code, then bug identification can be performed, but it becomes impractical when source code is not available on client computing devices
Solution Approach 1:
The patent creates a copy of the production environment's execution state by generating a log file that captures program execution addresses, call stacks, and variable states. This log file serves as a virtual copy of the running program, allowing debugging operations to be performed on the copied data rather than requiring direct access to the production environment or source code.
Solution Approach 2:
The patent introduces a log file as an intermediary between the production environment and the debugging process. The log file captures and stores execution state information, serving as a mediator that enables debugging analysis without requiring direct debugger access to the production system or source code files.
2Productivity
If a debugger is physically executed on the production environment, then real-time debugging is possible, but it is inefficient for large log files exceeding 100 Mb
Solution Approach 1:
The patent performs preliminary action by capturing and storing the program execution state in a log file before debugging analysis is needed. This pre-captured log file contains all necessary execution information (addresses, call stacks, variables), eliminating the need for time-consuming real-time debugging operations on large datasets later.
Solution Approach 2:
The patent extracts the essential debugging information (execution addresses, call stack data, variable states) from the running program and stores it in a separate log file. This extraction allows debugging analysis to be performed on the extracted data without requiring the actual program execution, significantly improving efficiency for large-scale debugging scenarios.
3Ease of manufacture
If source code is not available on client computing devices, then deployment is simplified, but bug identification and elimination become impossible
Solution Approach 1:
The patent creates a virtual copy of the source code execution state through the log file, which contains mapped execution addresses and corresponding source code information. This allows debugging operations to access source code context without requiring the actual source code files to be present on the client device, maintaining deployment simplicity while enabling bug detection.
Data Source
AI summary
A computer receives a log file, where the log file comprises records associated with the instructions in a source code. The computer loads, using a debugger, the log file and the source code. The computer receives a loading address from the log file. The computer updates a debugging data format (DWARF) with the one or more records of the log file, where the DWARF is accessed using the loading address and comprises one or more data structure entries. The computer identifies a calling address from the log file and identifies the one or more data structure entries associated with the calling address.