Computer program, system and method for generating a visualization of blocks of code statements associated with errors in a log file

Abstract

To provide a computer program, system and method for generating visualization of blocks of code statements related to errors in a log file.SOLUTION: A log file logs errors in execution of a program code. A source code, from which the program code is compiled, is analyzed to determine blocks of statements in the source code whose execution resulted in the errors in the log file. The blocks of statements in the source code are annotated with the errors in the log file caused by the blocks of statements. Execution of a block of statements annotated with an error resulted in the error logged in the log file. The annotated blocks of statements are processed to generate a video providing visualization of the blocks of statements in the source code whose execution resulted in the errors.SELECTED DRAWING: Figure 1

Description

[Technical Field]

[0001] 1.Technical Field The present invention relates to a computer program, system and method for generating a visualization of blocks of code statements associated with errors in a log file. [Background technology]

[0002] 2. Description of related technical fields In software development, developers analyze log files containing logged errors to determine the source of the errors in order to determine whether changes need to be made to program source code. Additionally, during application deployment, log files may be generated that list occurring errors that may cause disruptions to the user experience. Developers or users analyze the log files to determine the source of the errors and the corrective actions to implement. Developers may examine the log files to determine whether changes to the source code are needed, and users may review the log files for errors and determine the type of corrective action that may be appropriate, such as downloading a program update or notifying a company of the error. Log files can be difficult to review because they may have hundreds of error entries with abbreviated descriptions that may not convey the source of the problem. Summary of the Invention [Problem to be solved by the invention]

[0003] There is a need in the art for improved techniques to assist application developers and users in understanding logged errors in log files. [Means for solving the problem]

[0004] A computer program product, system, and method are provided for generating a visualization of blocks of code statements associated with errors in a log file. The log file logs errors in the execution of program code. The source code from which the program code is compiled is analyzed to determine blocks of statements in the source code whose execution resulted in errors in the log file. The blocks of statements in the source code are annotated with errors in the log file caused by the blocks of statements. Execution of the blocks of statements annotated with errors resulted in the errors logged in the log file. The annotated blocks of statements are processed to generate a video that provides a visualization of the blocks of statements in the source code whose execution resulted in the errors. [Brief explanation of the drawings]

[0005] [Figure 1] 1 illustrates an embodiment of a computing device in which embodiments may be implemented.

[0006] [Figure 2] 1 shows an example of a source code visualization using a log file, a block of statements in the log file annotated with the log file error that is related to the error, a flowchart generated to show the flow of the block of statements in the source code that is related to the error, and avatars that symbolize the manual entry of information into the program.

[0007] [Figure 3a] 10 illustrates an embodiment of an operation for generating a video that includes a visualization of a block of source code statements associated with an error in a log file. [Figure 3b] 10 illustrates an embodiment of an operation for generating a video that includes a visualization of a block of source code statements associated with an error in a log file.

[0008] [Figure 4] 1 illustrates a computing environment in which the components of FIG. 1 may be implemented. DETAILED DESCRIPTION OF THE INVENTION

[0009] The described embodiments provide improvements to computer technology to assist users or software developers in understanding the nature of generated errors, such as errors in log files and how those errors relate to the underlying source code whose execution resulted in the error. To allow users to visualize the source of an error, the described embodiments provide a technique that generates an animated video of the code statements whose execution resulted in a selected error, allowing the user to observe in the video the code that resulted in the logged error. Furthermore, if the error propagates as the problem escalates, the described embodiments may then provide a visualization of the program statements that shows how the error propagates during execution.

[0010] The described embodiments provide improvements in computer techniques for analyzing log files to identify activities that result in logged errors that are performed automatically based on program logic and activities that are manually triggered by user input. The described embodiments create visualizations in the form of animated footage that show a flow chart of the code statements involved in generating the errors in the log files. The animation for the code statements that receive user input and result in the errors may include animation representing the user input to visually direct the user's attention to the error associated with the user input, which often causes the logged error.

[0011] 1 illustrates an embodiment of a computing device 100 upon which embodiments may be implemented. Computing device 100 includes a processor 102 and a main memory 104. Main memory 104 includes various program components and files, including an operating system 108, a visualization manager 110 that manages the process of creating a visualization from errors in a log file 112, a code analyzer 114 that processes errors in log file 112 and source code 116 to determine blocks of statements in source code 116 whose execution results in logged errors, annotated blocks of statements 118 generated by code analyzer 114 that include blocks of statements annotated with error statements in log file 112, and a source code analyzer 116 that manages the process of creating a visualization from errors in log file 112. a graphics development tool 120 for processing the annotated blocks of statements 118 and generating a flowchart 122 illustrating the flow of the blocks of statements and generating a visualization 124 of the blocks of statements animated with representations of the user input; and a video generator 126 for receiving the flowchart 122 and the visualization 124 of the blocks of statements animated with representations of the user input and generating frames of video 128 that animate steps of the flowchart representing blocks of source code 116 statements that result in the logged error, and that animate the source code with graphics showing statements including the user input that result in the error.

[0012] The memory 104 may include any suitable volatile or non-volatile memory device, including those described above.

[0013] Generally, program modules, such as program components 108, 110, 114, 120, 126, may include routines, programs, objects, components, logic, data structures, etc. that perform particular tasks or implement particular abstract data types. The program components and hardware devices of computing device 100 of FIG. 1 may be implemented in one or more computer systems, where, when implemented in multiple computer systems, the computer systems may then communicate over a network.

[0014] The program components 108, 110, 114, 120, 126 may be accessed by the processor 102 for execution from the memory 104. Alternatively, some or all of the program components 108, 110, 114, 120, 126 may be implemented in separate hardware devices, such as application specific integrated circuit (ASIC) hardware devices.

[0015] The functions described as being performed by programs 108, 110, 114, 120, 126 may be implemented as program code in fewer program modules than shown, or may be implemented as program code across more program modules than shown.

[0016] 2 shows how the log file 112 of enumerated errors maps to blocks of statements in source code 200, which is then annotated with the errors in the log file 112. A graphical development tool receives the log file 112, a user selection of errors in the log file 112, and blocks of statements 210 in the source code 116 whose execution resulted in the user-selected error in the log file 112, and generates a flowchart 202 showing the flow of the blocks of statements that result in the errors from the log file 112 selected by the user, and generates a visualization 204, which may be implemented as a file or object, having statements 210′ ​​whose execution results in the selected error in the log file 112 including animation of avatars 206 for those blocks of statements 210′ ​​that result in the logged error selected by the user. The video generator 126 may generate a frame showing the flowchart 202, followed by a frame 204 showing a visualization of a block of statement 210′ ​​animated with a representation of a user 206 representing user input received during execution of the block of statement 210. The flowchart 202 shows one frame of the flowchart with a first step 208 in the flowchart highlighted, and the next frame 204 follows frame 202 and shows the block of statement 210′ ​​for the highlighted step 208 and the user's avatar 206 representing user input received during execution of statement 210′. In this manner, the user is provided with video 128 showing an animation of the flow of statement 202 resulting in a selected error, and a graphic of the user 206 in the frame of statement 210′ ​​from the highlighted step 208 in the flowchart 202, where user input is received to draw the user's attention to those statements 210 in step 208, resulting in the error for which the user input was received.

[0017] 3a and 3b illustrate an embodiment of operations performed by visualization manager 110, code analyzer 114, graphical development tool 120, and image generator 126 to generate image 128 that provides a visualization of a block of statements in source code whose execution contributed to the occurrence of a selected error in log file 112. Upon receiving a user selection of one or more error entries in error log file 112 (which may include selection of the entire log file 112 or a subset of entries), visualization manager 110 invokes (at block 302) code analyzer 114 to determine the block of statements in source code 116 whose execution resulted in the error for the selected entry in log file 112. Code analyzer 114 may use information in the selected entry in log file 112 to identify the statement in source code 116 whose execution resulted in the error. The code analyzer 114 annotates (at block 304) the determined blocks of statements from the source code 116 with information in the selected entries for errors caused by the blocks of statements to generate annotated blocks of statements 118. The annotated blocks of statements 118 map errors in the log to the source code 116 whose execution resulted in the error. The code analyzer 114 processes (at block 306) the annotated blocks of statements 118 to determine if any statements receive user input via a user interface.

[0018] If there is a block of statements that results in a logged error receiving user input (at block 308), then graphical development tool 120 captures (at block 310) a screenshot of the user interface where the input entered by the user at the block of statements results in the logged error. An animation is generated (at block 312) in visualization 124 of the block of statements animated with a representation of the user input showing the user interface screenshot, or a person's avatar adjacent to the block of statements where the user input was received, or a combination thereof. If there is not (at block 308) a block of statements that results in an error after the user input is received or generates visualization 124 of the block of statements with an animation of the user input (at block 312), then graphical development tool 120 processes (at block 314) the timestamps of the selected log entries to determine the order in which the errors occurred. The graphical development tool 120 processes (at block 316) the annotated blocks of statements 118 and the order of the blocks of statements to generate a flowchart 122 illustrating a flow of steps having blocks of statements that resulted in errors in the selected entries of the log file 112. Each step of the flowchart 122 may include one or more statements in the blocks of statements that resulted in one of the selected errors. The steps of the flowchart having statements that resulted in errors may be ordered according to the timestamps of the errors in the error entries in the log file. Control then passes to block 320 of FIG. 3b.

[0019] A loop of operations is performed from blocks 320 to 328 for each step i in the flowchart 122. The image generator 126 generates (at block 322) a frame in the video stream 128 showing the flowchart 122 with step i highlighted to indicate that the step is currently being processed. If step i includes receiving user input (at block 324), then the image generator 126 generates (at block 326) a frame in the video stream 128 showing the source code block of the statement corresponding to step i in the flowchart 122 using an animation of a user interface screenshot or a person avatar, or a combination thereof, to indicate the user input for the block of statement represented in the highlighted step i. If step i in the flowchart 122 does not receive user input (at block 324), then the image generator 126 generates (at block 328) a frame in the video stream 128 showing the source code block of the statement corresponding to step i in the flowchart 122. After generating a frame showing the corresponding source code in block 326 or 328, control proceeds (at block 330) back to block 320 to process the next step (i+1) in flowchart 122, if there are more steps. In this manner, video generator 126 may generate at least one frame for the execution of each step in flowchart 122 flow to show the execution of program statements that resulted in errors in the order of their timestamps relative to the error entries in log file 112. Video stream 128 is preferably played back (at block 332) simultaneously as the user browses through log file 112 to provide a visual representation of the source code flow of statements, allowing a user or developer to better understand the occurrence of errors in the log file through visualization of the source code associated with those errors.

[0020] 3a and 3b, when a user selects an error entry of interest in log file 112, source code 116 is processed to determine the statement causing the error, a flowchart-style visualization of the source code statements, and the statement relative to the flowchart stage. Because many errors that occur may be the result of user input as opposed to errors or bugs in source code 116, the visualization of blocks of statements where user input is received may provide animation of the user input to draw the user's attention to the section of the statement that receives the user input. Furthermore, because computer users are accustomed to seeing visual representations of technical solutions and fixes, this real-time generation of a video showing the code flow that resulted in the selected error may help the user better understand the source of the error in the code execution.

[0021] In further embodiments, a developer may use a virtual reality interface to visualize animated video 128, interact with objects created within the virtual reality environment, and even recreate problems in the virtual reality environment by selecting steps in the flowchart 122 rendered in the video to view source code statements or runtime parameters.

[0022] In a further embodiment, there may be hierarchies of log files, such as an application hierarchies, a database hierarchies, etc., such as when an application issues a database query to interact with a database. In such a case, a user may select an error from multiple hierarchies of log files, and flowchart 122 may show the steps through the multiple hierarchies to provide a visualization of the code associated with the selected error in separate hierarchical log files for separate program hierarchies, such as the database hierarchies, the application hierarchies, the network hierarchies, etc. The described embodiments may form correlations between different hierarchical log files from different hierarchies using analysis of log types and timestamps. A user may select a log from one hierarchies and navigate to the corresponding associated log for that issue in another hierarchies seamlessly using visual interaction, such as a virtual reality interface.

[0023] In further embodiments, the knowledge corpus may be formed based on errors in the log file 112, such as root cause analysis, repairs, etc. The knowledge corpus may be formed based on data previously captured from the application. Information in the knowledge corpus may be reproduced in the video upon analysis of the knowledge corpus and determining suggestions related to the errors and corresponding blocks of statements in the log file.

[0024] The present invention may be a system, a method, or a computer program product, or a combination thereof. The computer program product may include a computer-readable storage medium (or multiple computer-readable storage media) having computer-readable program instructions for causing a processor to perform aspects of the present invention.

[0025] A computer-readable storage medium may be a tangible device that can hold and store instructions for use by an instruction execution device. The computer-readable storage medium may be, for example, but not limited to, an electronic storage device, a magnetic storage device, an optical storage device, an electromagnetic storage device, a semiconductor storage device, or any suitable combination of the foregoing. A non-exhaustive list of more specific examples of computer-readable storage media includes the following: portable computer diskettes, hard disks, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), static random access memory (SRAM), portable compact disk read-only memory (CD-ROM), digital versatile disk (DVD), memory sticks, floppy disks, mechanically encoded devices such as punch cards or ridge structures in grooves that record instructions, and any suitable combination of the foregoing. As used herein, computer-readable storage media should not be construed as being transitory signals themselves, such as radio waves or other freely propagating electromagnetic waves, electromagnetic waves propagating through a waveguide or other transmission medium (e.g., light pulses passing through a fiber optic cable), or electrical signals transmitted over wires.

[0026] The computer-readable program instructions described herein may be downloaded from a computer-readable storage medium to each computing / processing device or to an external computer or external storage device via a network, such as the Internet, a local area network, a wide area network, or a wireless network, or a combination thereof. The network may include copper transmission cables, optical fiber transmissions, wireless transmissions, routers, firewalls, switches, gateway computers or edge servers, or a combination thereof. A network adapter card or network interface in each computing / processing device receives the computer-readable program instructions from the network and transfers the computer-readable program instructions to a computer-readable storage medium in the respective computing / processing device for storage.

[0027] The computer-readable program instructions for carrying out the operations of the present invention may be assembler instructions, instruction set architecture (ISA) instructions, machine instructions, machine-dependent instructions, microcode, firmware instructions, state-setting data, or source or object code written in any combination of one or more programming languages, including object-oriented programming languages ​​such as Java, Smalltalk, C++, etc., and conventional procedural programming languages ​​such as the "C" programming language or similar programming languages. The computer-readable program instructions may execute entirely on the user's computer, partially on the user's computer as a stand-alone software package, partially on the user's computer and partially on a remote computer, or entirely on a remote computer or server. In the latter scenario, the remote computer may be connected to the user's computer via any type of network, including a local area network (LAN) or a wide area network (WAN), or the connection may be to an external computer (e.g., via the Internet using an Internet Service Provider). In some embodiments, electronic circuitry including, for example, a programmable logic circuit, a field programmable gate array (FPGA), or a programmable logic array (PLA) may execute computer-readable program instructions to personalize the electronic circuitry by utilizing state information of the computer-readable program instructions to perform aspects of the present invention.

[0028] Aspects of the present invention are described herein with reference to flowchart illustrations or block diagrams, or combinations thereof, of methods, apparatus (systems), and computer program products according to embodiments of the invention. It will be understood that each block of the flowchart illustrations or block diagrams, or combinations thereof, and combinations of blocks in the flowchart illustrations or block diagrams, or combinations thereof, can be implemented by computer-readable program instructions.

[0029] These computer-readable program instructions may be provided to a processor of a general-purpose computer, a special-purpose computer, or other programmable data processing apparatus causing a machine to perform the functions / acts specified in one or more blocks of the flowcharts or block diagrams, or a combination thereof. These computer-readable program instructions may also be stored on a computer-readable storage medium capable of instructing a computer, programmable data processing apparatus, or other device, or a combination thereof, to function in a particular manner, such that the computer-readable storage medium having the instructions stored thereon comprises an article of manufacture containing instructions that implement aspects of the functions / acts specified in one or more blocks of the flowcharts or block diagrams, or a combination thereof.

[0030] The computer-readable program instructions may also be loaded into a computer, other programmable data processing apparatus, or other device and cause the computer, other programmable apparatus, or other device to perform a series of operational steps to generate a computer-implemented process, such that the instructions executing on the computer, other programmable apparatus, or other device implement the functions / acts specified in one or more blocks of the flowcharts or block diagrams or a combination thereof.

[0031] The flowcharts and block diagrams in the figures illustrate the architecture, functionality, and operation of possible implementations of systems, methods, and computer program products according to various embodiments of the present invention. In this regard, each block in a flowchart or block diagram may represent a module, segment, or portion of instructions, including one or more executable instructions, that implement a specified logical function. In some alternative implementations, the functions noted in the blocks may occur out of the order noted in the figures. For example, two blocks shown in succession may, in fact, be executed substantially simultaneously, or the blocks may possibly be executed in the reverse order, depending on the functionality involved. It should also be noted that each block of a block diagram or flowchart diagram, or a combination thereof, and combinations of blocks in block diagrams or flowchart diagrams, or a combination thereof, may be implemented by a dedicated hardware-based system that performs the specified functions or operations or executes a combination of dedicated hardware and computer instructions.

[0032] The computational components of FIG. 1 , including computer system 100, may be implemented in one or more computer systems, such as computer system 402 shown in FIG. 4 . Computer system / server 402 may be described in the general context of computer system-executable instructions, such as program modules, being executed by a computer system. Generally, program modules may include routines, programs, objects, components, logic, data structures, etc., that perform particular tasks or implement particular abstract data types. Computer system / server 402 may be practiced in a distributed cloud computing environment where tasks are performed by remote processing devices linked through a communications network. In a distributed cloud computing environment, program modules may be located in both local and remote computer system storage media, including memory storage devices.

[0033] 4, computer system / server 402 is shown in the form of a general-purpose computing device. Components of computer system / server 402 may include, but are not limited to, one or more processors or processing units 404, a system memory 406, and a bus 408 that couples various system components, including the system memory 406, to the processor 404. Bus 408 represents any one or more of several types of bus structures, including a memory bus or memory controller, a peripheral bus, an accelerated graphics port, and a processor or local bus using any of a variety of bus architectures. By way of example, and without limitation, such architectures include an Industry Standard Architecture (ISA) bus, a MicroChannel Architecture (MCA) bus, an Enhanced ISA (EISA) bus, a Video Electronics Standards Association (VESA) local bus, and a Peripheral Component Interconnect (PCI) bus.

[0034] Computer system / server 402 typically includes a variety of computer system-readable media. Such media can be any available media that can be accessed by computer system / server 402 and includes both volatile and nonvolatile media, removable and non-removable media.

[0035] The system memory 406 may include computer system-readable media in the form of volatile memory, such as random access memory (RAM) 410 or cache memory 412, or a combination thereof. The computer system / server 402 may further include other removable / non-removable, volatile / non-volatile computer system storage media. By way of example only, a storage system 413 may be provided for reading from and writing to a non-removable, non-volatile magnetic medium (typically referred to as a “hard drive” and not shown). Although not shown, a magnetic disk drive may be provided for reading from or writing to a removable, non-volatile magnetic disk (e.g., a “floppy disk”), and an optical disk drive may be provided for reading from and writing to a removable, non-volatile optical disk, such as a CD-ROM, DVD-ROM, or other optical media. In such cases, each disk drive may be connected to the bus 408 by one or more data media interfaces. As further illustrated and described below, the memory 406 may include at least one program product including a set (e.g., at least one) of program modules configured to perform the functions of embodiments of the present invention.

[0036] Programs / utilities 414, including a set (at least one) of program modules 416, as well as an operating system, one or more application programs, other program modules, and program data, may be stored in memory 406, by way of example and not limitation. Each of the operating system, one or more application programs, other program modules, and program data, or some combination thereof, may include implementation in a networking environment. Components of computer 402 may be implemented as program modules 416 that generally perform the functions or methods, or combinations thereof, of the embodiments of the invention described herein. The system of FIG. 1 may be implemented in one or more computer systems 402, where, when implemented in multiple computer systems 402, the computer systems may then communicate over a network.

[0037] The computer system / server 402 may also communicate with one or more external devices 418, such as a keyboard, pointing device, display 420, one or more devices that allow a user to interact with the computer system / server 402, or any device (e.g., a network card, modem, etc.) that allows the computer system / server 402 to communicate with one or more other computing devices, or a combination thereof. Such communication may occur via an input / output (I / O) interface 422. Furthermore, the computer system / server 402 may communicate with one or more networks, such as a local area network (LAN), a general wide area network (WAN), or a public network (e.g., the Internet) or a combination thereof, via a network adapter 424. As depicted, the network adapter 424 communicates with other components of the computer system / server 402 via a bus 408. Although not shown, it should be understood that other hardware or software or combinations of components may be used in conjunction with the computer system / server 402. Examples include, but are not limited to, microcode, device drivers, redundant processing units, external disk drive arrays, RAID systems, tape drives, and data archive storage systems.

[0038] The terms "an embodiment," "embodiment," "embodiments," "the embodiment," "the embodiment," "the embodiments," "one or more embodiments," "some embodiments," and "one embodiment" mean "one or more (but not all) embodiments of the present invention," unless expressly specified otherwise.

[0039] The terms "including," "comprising," "having," or variations thereof mean "including, but not limited to," unless expressly specified otherwise.

[0040] The enumerated listing of items does not imply that any or all of the items are mutually exclusive, unless expressly specified otherwise.

[0041] The terms "a," "an," and "the" mean "one or more," unless expressly specified otherwise.

[0042] Devices that are in communication with each other are not necessarily in continuous communication with each other unless explicitly specified otherwise. In addition, devices that are in communication with each other may communicate directly or indirectly through one or more intermediaries.

[0043] A description of an embodiment having several components in communication with each other does not imply that all such components are required, but rather a variety of optional components are described to illustrate the wide range of possible embodiments of the present invention.

[0044] Where a single device or article is described herein, it will be readily apparent that more than one device / article (whether or not they cooperate) may be substituted for the single device / article. Similarly, where more than one device or article is described herein (whether or not they cooperate), it will be readily apparent that a single device / article may be substituted for more than one device or article, or that a different number of devices / articles may be substituted for the number of devices or programs shown. The functionality or features of a device, or combinations thereof, may alternatively be embodied by one or more other devices not explicitly described as having such functionality / features. Thus, other embodiments of the present invention need not include the device itself.

[0045] The foregoing description of various embodiments of the invention has been presented for purposes of illustration and description. It is not intended to be exhaustive or to limit the invention to the precise form disclosed. Many modifications and variations are possible in light of the above teachings. It is intended that the scope of the invention be limited not by this detailed description, but rather by the claims appended hereto. The above specification, examples and data provide a complete description of the manufacture and use of the compositions of the invention. Since many embodiments of the invention can be made without departing from the spirit and scope of the invention, the invention resides in the claims hereinafter appended.

Claims

1. 1. A computer program for providing visualization of errors in program code, the computer program comprising computer readable program code executable to perform operations, the operations comprising: providing a log file that logs errors in the execution of the program code; analyzing source code from which the program code is compiled to determine blocks of statements in the source code whose execution results in the errors in the log file; annotating blocks of statements in the source code with the errors in the log file caused by the blocks of statements, wherein execution of the blocks of statements annotated with errors results in the errors being logged in the log file; capturing a screenshot of the user interface with user input; processing the annotated block of statements to generate a video providing a visualization of the block of statements in the source code whose execution resulted in the error and a captured screenshot of the user interface where a user input resulting in the error occurred; a computer program comprising:

2. A computer program for providing visualization of errors in program code, the computer program comprising computer-readable program code executable to perform operations, the operations comprising: providing a log file that logs errors in the execution of the program code; analyzing source code from which the program code is compiled to determine blocks of statements in the source code whose execution results in the errors in the log file; annotating blocks of statements in the source code with the errors in the log file caused by the blocks of statements, wherein execution of the blocks of statements annotated with errors results in the errors being logged in the log file; processing the annotated block of statements to generate a visual that provides a visualization of the block of statements in the source code whose execution results in the error; Including, the log file indicates timestamps of when the errors occurred in the log file, and analyzing the source code includes determining the order in which the blocks of statements in the source code were executed to generate the errors in the log file, the order being based on the timestamps of the errors, and the blocks of statements that result in the errors in the log file are visualized in the video in the order in which they were executed to generate the errors in the log file.

3. A computer program for providing visualization of errors in program code, the computer program comprising computer readable program code executable to perform operations, the operations comprising: providing a log file that logs errors in the execution of the program code; analyzing source code from which the program code is compiled to determine blocks of statements in the source code whose execution results in the errors in the log file; annotating blocks of statements in the source code with the errors in the log file caused by the blocks of statements, wherein execution of the blocks of statements annotated with errors results in the errors being logged in the log file; processing the annotated blocks of statements to generate a visual representation providing a visualization of the blocks of statements in the source code whose execution results in the error; determining blocks of statements in the source code whose execution results in errors in the log file receiving user input via a user interface, the generated video providing the visualization of the determined blocks of statements in an animation representing the user input received and adjacent to the determined blocks of statements; capturing an image of a user interface in which a user enters the user input during execution of the block of statements, and rendering the animation representing the user input using the visualization of the determined block of statements in the captured image of the user interface.

4. A computer program for providing visualization of errors in program code, the computer program comprising computer readable program code executable to perform operations, the operations comprising: providing a log file that logs errors in the execution of the program code; analyzing source code from which the program code is compiled to determine blocks of statements in the source code whose execution results in the errors in the log file; annotating blocks of statements in the source code with the errors in the log file caused by the blocks of statements, wherein execution of the blocks of statements annotated with errors results in the errors being logged in the log file; processing the annotated blocks of statements to generate a visual representation providing a visualization of the blocks of statements in the source code whose execution results in the error; determining blocks of statements in the source code whose execution results in errors in the log file receiving user input via a user interface, the generated video providing the visualization of the determined blocks of statements in an animation representing the user input received and adjacent to the determined blocks of statements; Including, The animation representing the user input includes rendering an animation of a person using the visualization of the determined block of statements.

5. A computer program for providing visualization of errors in program code, the computer program comprising computer readable program code executable to perform operations, the operations comprising: providing a log file that logs errors in the execution of the program code; analyzing source code from which the program code is compiled to determine blocks of statements in the source code whose execution results in the errors in the log file; annotating blocks of statements in the source code with the errors in the log file caused by the blocks of statements, wherein execution of the blocks of statements annotated with errors results in the errors being logged in the log file; processing the annotated block of statements to generate a visual that provides a visualization of the block of statements in the source code whose execution results in the error; Including, a computer program, wherein the visualization in the video includes a first frame that renders an animation of progressing through steps in a flowchart corresponding to the block of statements that result in an error in the log file, and a second frame that renders an animation of user input at the block of statements that generates the error corresponding to the step in the first frame of the flowchart.

6. 6. The computer program product of claim 5, wherein the second frame renders a graphic representing a person at a block of statements that receives user input and causes the error in the log file.

7. A computer program for providing visualization of errors in program code, the computer program comprising computer readable program code executable to perform operations, the operations comprising: providing a log file that logs errors in the execution of the program code; analyzing source code from which the program code is compiled to determine blocks of statements in the source code whose execution results in the errors in the log file; annotating blocks of statements in the source code with the errors in the log file caused by the blocks of statements, wherein execution of the blocks of statements annotated with errors results in the errors being logged in the log file; processing the annotated block of statements to generate a visual that provides a visualization of the block of statements in the source code whose execution results in the error; Including, 1. A computer program product comprising: a computer program code for executing a program at a plurality of tiers, each tier having a separate tier log file indicating errors that occur when executing code at the tier, the tier log file indicating a timestamp at which the error occurred within the tier log file; wherein analyzing the source code includes determining an order in which blocks of statements in the source code were executed relative to the tier to generate the error in the tier log file, the order being based on the timestamp of the error in the tier log file; and wherein the blocks of statements are visualized in the video in the order in which they were executed across the tiers to generate the error in the tier log file.

8. The operations further comprise:

8. The computer program product of claim 1, further comprising: determining blocks of statements in the source code whose execution results in errors in the log file receiving user input via a user interface, wherein the generated video provides the visualization of the determined blocks of statements in an animation representing the user input received and adjacent to the determined blocks of statements.

9. The visualization of the block of statements may include: generating a flowchart showing the flow of the blocks of statements; 8. A computer program as claimed in any one of claims 1 to 7, comprising generating frames in the video that highlight the steps in the flowchart in different frames to show the flow of execution of the steps in the flowchart.

10. The operations further comprise:

8. The computer program product of claim 1, further comprising: receiving a user selection of a group of errors in the log file; analyzing the source code comprising determining blocks of statements in the source code whose execution results in the selected group of errors; annotating the blocks of statements comprising annotating the determined blocks of statements that result in the selected group of errors; and the video providing a visualization of the blocks of statements that result in the selected group of errors in the log file.

11. 1. A system for providing visualization of errors in program code, comprising: a processor; a computer-readable storage medium having computer-readable program code embodied therein that performs operations when executed by said processor; and the operation comprises: providing a log file that logs errors in the execution of the program code; analyzing source code from which the program code is compiled to determine blocks of statements in the source code whose execution results in the errors in the log file; annotating blocks of statements in the source code with the errors in the log file caused by the blocks of statements, wherein execution of the blocks of statements annotated with errors results in the errors being logged in the log file; capturing a screenshot of the user interface with user input; processing the annotated block of statements to generate a video providing a visualization of the block of statements in the source code whose execution results in the error and a captured screenshot of the user interface that results in the error; Including, the system.

12. A system for providing visualization of errors in program code, comprising: a processor; a computer-readable storage medium having computer-readable program code embodied therein that performs operations when executed by said processor; and the operation comprises: providing a log file that logs errors in the execution of the program code; analyzing source code from which the program code is compiled to determine blocks of statements in the source code whose execution results in the errors in the log file; annotating blocks of statements in the source code with the errors in the log file caused by the blocks of statements, wherein execution of the blocks of statements annotated with errors results in the errors being logged in the log file; processing the annotated block of statements to generate a visual that provides a visualization of the block of statements in the source code whose execution results in the error; Including, the log file indicates a timestamp of when the error occurred in the log file, and analyzing the source code includes determining an order in which the blocks of statements in the source code were executed to generate the error in the log file, the order being based on the timestamp of the error, and the blocks of statements that result in the error in the log file are visualized in the video in the order in which they were executed to generate the error in the log file.

13. A system for providing visualization of errors in program code, comprising: a processor; a computer-readable storage medium having computer-readable program code embodied therein that performs operations when executed by said processor; and the operation comprises: providing a log file that logs errors in the execution of the program code; analyzing source code from which the program code is compiled to determine blocks of statements in the source code whose execution results in the errors in the log file; annotating blocks of statements in the source code with the errors in the log file caused by the blocks of statements, wherein execution of the blocks of statements annotated with errors results in the errors being logged in the log file; processing the annotated block of statements to generate a visual that provides a visualization of the block of statements in the source code whose execution results in the error; Including, The visualization in the video includes a first frame that renders an animation of progressing through steps in a flowchart corresponding to the block of statements that result in an error in the log file, and a second frame that renders an animation of user input at the block of statements that generates the error corresponding to the step in the first frame of the flowchart.

14. The operations further comprise:

14. The system of claim 11, further comprising: determining blocks of statements in the source code whose execution results in errors in the log file receiving user input via a user interface, wherein the generated video provides the visualization of the determined blocks of statements in an animation representing the user input received and adjacent to the determined blocks of statements.

15. The operations further comprise:

14. The system of claim 11, further comprising: receiving a user selection of a group of errors in the log file; wherein analyzing the source code comprises determining the blocks of statements in the source code whose execution results in the selected group of errors; annotating the blocks of statements comprises annotating the determined blocks of statements that result in the selected group of errors; and wherein the video provides a visualization of the blocks of statements that result in the selected group of errors in the log file.

16. 1. A method for providing visualization of errors in program code, comprising: providing a log file in which the computing device logs errors in the execution of the program code; analyzing, by the computing device, source code from which the program code is compiled to determine blocks of statements in the source code whose execution results in the errors in the log file; annotating, by the computing device, blocks of statements in the source code with the errors in the log file caused by the blocks of statements, wherein execution of the blocks of statements annotated with errors results in the errors being logged in the log file; capturing, by the computing device, a screenshot of a user interface with user input; processing, by the computing device, the annotated block of statements to generate a video providing a visualization of the block of statements in the source code whose execution results in the error and a captured screenshot of the user interface that results in the error; A method comprising:

17. A method for providing visualization of errors in program code, comprising: providing a log file in which the computing device logs errors in the execution of the program code; analyzing, by the computing device, source code from which the program code is compiled to determine blocks of statements in the source code whose execution results in the errors in the log file; annotating, by the computing device, blocks of statements in the source code with the errors in the log file caused by the blocks of statements, wherein execution of the blocks of statements annotated with errors results in the errors being logged in the log file; processing, by the computing device, to process the annotated blocks of statements to generate a video that provides a visualization of the blocks of statements in the source code whose execution results in the error; Including, the log file indicates timestamps at which the errors occurred in the log file, and analyzing the source code includes determining the order in which the blocks of statements in the source code were executed to generate the errors in the log file, the order being based on the timestamps of the errors, and the blocks of statements that result in the errors in the log file are visualized in the video in the order in which they were executed to generate the errors in the log file.

18. A method for providing visualization of errors in program code, comprising: providing a log file in which the computing device logs errors in the execution of the program code; analyzing, by the computing device, source code from which the program code is compiled to determine blocks of statements in the source code whose execution results in the errors in the log file; annotating, by the computing device, blocks of statements in the source code with the errors in the log file caused by the blocks of statements, wherein execution of the blocks of statements annotated with errors results in the errors being logged in the log file; processing, by the computing device, to process the annotated blocks of statements to generate a video that provides a visualization of the blocks of statements in the source code whose execution results in the error; Including, The visualization in the video includes a first frame that renders an animation of progressing through steps in a flowchart corresponding to the block of statements that result in an error in the log file, and a second frame that renders an animation of user input at the block of statements that generates the error corresponding to the step in the first frame of the flowchart.

19. A method according to any one of claims 16 to 18, further comprising a step in which the computing device determines blocks of statements in the source code whose execution results in errors in the log file receiving user input via a user interface, and the generated video provides the visualization of the determined blocks of statements in an animation representing the user input received and adjacent to the determined blocks of statements.

20. A method according to any one of claims 16 to 18, further comprising the step of: the computing device receiving a user selection of a group of errors in the log file; wherein the step of analyzing the source code comprises determining the blocks of statements in the source code whose execution results in the selected group of errors; wherein the step of annotating the blocks of statements comprises annotating the determined blocks of statements that result in the selected group of errors; and wherein the video provides a visualization of the blocks of statements that result in the selected group of errors in the log file.

Images