US20080147853A1 - Remote monitoring of computer programs - Google Patents
Remote monitoring of computer programs Download PDFInfo
- Publication number
- US20080147853A1 US20080147853A1 US11/986,310 US98631007A US2008147853A1 US 20080147853 A1 US20080147853 A1 US 20080147853A1 US 98631007 A US98631007 A US 98631007A US 2008147853 A1 US2008147853 A1 US 2008147853A1
- Authority
- US
- United States
- Prior art keywords
- computer program
- data
- computer system
- execution
- monitoring instruction
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Abandoned
Links
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/36—Preventing errors by testing or debugging software
- G06F11/362—Software debugging
- G06F11/366—Software debugging using diagnostics
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/07—Responding to the occurrence of a fault, e.g. fault tolerance
- G06F11/0703—Error or fault processing not based on redundancy, i.e. by taking additional measures to deal with the error or fault not making use of redundancy in operation, in hardware, or in data representation
- G06F11/0706—Error or fault processing not based on redundancy, i.e. by taking additional measures to deal with the error or fault not making use of redundancy in operation, in hardware, or in data representation the processing taking place on a specific hardware platform or in a specific software environment
- G06F11/0715—Error or fault processing not based on redundancy, i.e. by taking additional measures to deal with the error or fault not making use of redundancy in operation, in hardware, or in data representation the processing taking place on a specific hardware platform or in a specific software environment in a system implementing multitasking
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/30—Monitoring
- G06F11/34—Recording or statistical evaluation of computer activity, e.g. of down time, of input/output operation ; Recording or statistical evaluation of user activity, e.g. usability assessment
- G06F11/3466—Performance evaluation by tracing or monitoring
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/30—Monitoring
- G06F11/34—Recording or statistical evaluation of computer activity, e.g. of down time, of input/output operation ; Recording or statistical evaluation of user activity, e.g. usability assessment
- G06F11/3466—Performance evaluation by tracing or monitoring
- G06F11/3495—Performance evaluation by tracing or monitoring for systems
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/36—Preventing errors by testing or debugging software
- G06F11/362—Software debugging
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/22—Detection or location of defective computer hardware by testing during standby operation or during idle time, e.g. start-up testing
- G06F11/2294—Detection or location of defective computer hardware by testing during standby operation or during idle time, e.g. start-up testing by remote test
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F2201/00—Indexing scheme relating to error detection, to error correction, and to monitoring
- G06F2201/865—Monitoring of software
Definitions
- the Microfiche Appendix (17 fiche with total of 1027 frames) includes source code for implementing an embodiment of the invention.
- the present invention is related to remote monitoring of computer programs and, more particularly, to a adding remote monitoring instructions to a computer program so that the execution of the computer program may be monitored at a remote site.
- the present invention provides innovative systems and methods for remotely monitoring the execution of computer programs. Monitoring instructions (or data collecting instructions) are added the computer program so that during execution of the program, data may be collected regarding the program execution. The collected data may be automatically sent to a remote system or site for analysis.
- the present invention creates little or no performance impact on the client yet provides valuable information to the developer of the program.
- the present invention provides a method of remotely monitoring execution of a computer program in a computer system, comprising the steps of: modifying the computer program to include at least one monitoring instruction; executing the computer program; the at least one monitoring instruction collecting data regarding the execution of the computer program; and sending the collected data to a remote system.
- the present invention provides a distributed computer system, comprising: a server computer; a client computer in communication with the server computer; and a computer program running on the client computer that includes monitoring instructions that collect and send data regarding execution of the computer program to the server computer.
- the present invention provides a computer program product for remotely monitoring execution of a computer program, comprising: a computer readable storage medium storing the computer program comprising: code that calls at least one monitoring instruction, the at least one monitoring instruction collecting data regarding the execution of the computer program; and code that sends the collected data to a remote system
- FIG. 1 illustrates an example of a computer system used to execute the software of the present invention
- FIG. 2 shows a system block diagram of a typical computer system used to execute the software of the present invention
- FIG. 3 is a block diagram of a distributed computer system where a server computer may remotely monitor execution of computer programs on client computers;
- FIG. 4 is a high level flowchart of a process of remotely monitoring execution of a computer program
- FIG. 5 illustrates a mechanism operating systems utilize to access routines in a system library
- FIG. 6 illustrates utilizing hooks to intercept systems calls and PV API calls
- FIG. 7 is a table of types of end-run-conditions for computer programs and the information that may be available;
- FIG. 8 is a high level flowchart of a process of end-of-run processing of a computer program
- FIG. 9 is a high level flowchart of a process of performing remote debugging of a computer program
- FIG. 10 is a high level flowchart of a process of remotely upgrading the version of a computer program
- FIG. 11 is a block diagram of a bug tracker interfacing with a computer system of the present invention.
- FIG. 12 is a block diagram of a computer system remotely monitoring computer programs in a multi-tasking or multi-threaded environment
- FIG. 13 is a block diagram of a computer system remotely monitoring computer programs incorporating portions from multiple vendors.
- FIG. 14 shows an object code file augmented to include new data collection instructions.
- the present invention provides a remote data collection facility that may be utilized for developers to monitor a program under test (PUT).
- PUT is therefore a computer program or application that has been distributed to a client (or other site) for which the developer would like to monitor the execution remotely. This remote monitoring may be performed from pre-alpha through beta and final release.
- the present invention is incorporated in PureVision (PV) which is available from Pure Software Inc., Sunnyvale, Calif.
- FIG. 1 illustrates an example of a computer system used to execute the software of the present invention.
- FIG. 1 shows a computer system 1 which includes a monitor 3 , screen 5 , cabinet 7 , keyboard 9 , and mouse 11 .
- Mouse 11 may have one or more buttons such as mouse buttons 13 .
- Cabinet 7 houses a CD-ROM drive 15 , a system memory and a hard drive (see FIG. 2 ) which may be utilized to store and retrieve software programs incorporating code that implements the present invention, data for use with the present invention, and the like.
- a CD-ROM 17 is shown as an exemplary computer readable storage medium, other computer readable storage media including floppy disks, tape, flash memory, system memory, and hard drives may be utilized.
- Cabinet 7 also houses familiar computer components (not shown) such as a central processor, system memory, hard disk, and the like.
- FIG. 2 shows a system block diagram of computer system 1 used to execute the software of the present invention.
- computer system 1 includes monitor 3 and keyboard 9 .
- Computer system 1 further includes subsystems such as a central processor 102 , system memory 104 , I/O controller 106 , display adapter 108 , removable disk 112 (e.g., CD-ROM drive), fixed disk 116 (e.g., hard drive), network interface 118 , and speaker 120 .
- Other computer systems suitable for use with the present invention may include additional or fewer subsystems.
- another computer system could include more than one processor 102 (i.e., a multi-processor system) or a cache memory.
- Arrows such as 122 represent the system bus architecture of computer system 1 . However, these arrows are illustrative of any interconnection scheme serving to link the subsystems. For example, a local bus could be utilized to connect the central processor to the system memory and display adapter.
- Computer system 1 shown in FIG. 2 is but an example of a computer system suitable for use with the present invention. Other configurations of subsystems suitable for use with the present invention will be readily apparent to one of ordinary skill in the art.
- FIG. 3 is a block diagram of a distributed computer system where a server computer may remotely monitor execution of PUTs on client computers.
- a server computer 202 is in communication with multiple clients, of which clients 204 , 206 and 208 are shown.
- the server may communicate with the clients via transport mechanisms known in the art including HTTP, email, network of LAN or WAN, and the like. Additionally, the server and clients may communicate via a media like a floppy or tape as shown between the server and client 208 .
- the computer system that monitors a PUT will be designated a “server” and a computer system on which the PUT executes will be designed a “client.”
- the server computer will be described as the computer system that performs development of the PUT and remote monitoring of execution of the PUT.
- the development and remote monitoring may be performed on entirely different computer systems and at different locations.
- a client executes the PUT which includes additional monitoring instructions for collecting data regarding the PUT execution.
- the collected data may be stored locally on the client until it is transferred to the server for analysis.
- the collected data is sent or transferred to the server via a transport mechanism.
- the present invention provides a platform independent application programming interface (API) for directing the data collection for an executing PUT.
- client 204 is operating under the Unix operating system.
- client 206 is operating under one of the family of Windows operating systems.
- the API of the present invention (PV API) is portable as a same set of API calls apply to PUTs running on both operating systems. This functionality allows developers to create a single source tree across different platforms. Although platform-specific API calls may be provided, these calls will be ignored if the platform is incompatible.
- FIG. 4 is a high level flowchart of a process of remotely monitoring execution of a PUT.
- the flowchart is divided into a server-side and a client-side to indicate on which computer systems the steps are performed.
- the PV API is installed on the server computer for remotely monitoring the PUT.
- the PV API calls are stored in a dynamic-link library (DLL).
- DLL dynamic-link library
- hooks that are available in Windows may be utilized to intercept the system calls.
- a similar mechanism may be utilized for Unix systems.
- At least one PV API call is placed in the PUT source code at step 304 .
- the PV_Start call may be added to the PUT source code to start monitoring of the PUT during execution. Data will be collected regarding the execution and, in a preferred embodiment, the collected data will be automatically sent to the server. The data is typically collected until the PUT finishes execution.
- Other PV API calls may be utilized to customize the data collection. Thus, developers may dynamically change the data that will be collected over the application development cycle from pre-alpha to beta through final release.
- the PUT is compiled and linked into an executable computer program. After the PUT is a computer program that incorporates remote monitoring instructions, the PUT is sent to the client.
- the PUT may be sent to the client in any number of ways including networks and magnetic media like floppies.
- the PUT is executed at step 310 .
- multi-tasking and multi-threaded applications perform tasks in parallel, each task or thread essentially operates by executing statements in sequential order. Accordingly, in discussing this figure, all applications will be generalized to this sequential execution of statements.
- the next statement is retrieved.
- the client determines if the statement is a PV API call at step 314 . If it is not, the PUT statement is executed at step 316 .
- a PUT statement is basically any statement that is not a PV API call for remote monitoring.
- the client calls the PV API specified by the statement at step 318 .
- PV API calls There are numerous types of PV API calls that may be called including calls that perform the following:
- PV API calls there are a variety of PV API calls that may be made at step 318 .
- the goal of most of the calls revolves around data collection regarding the execution of the PUT.
- the PV API calls allow the developer to specify characteristics of the data that will be collected during a PUT run. For example, in addition to the developer being able to turn data collection on and off at locations in the PUT with PV_On and PV_Off, the developer is also able to specify that data collected under a given type should be discarded (e.g., to reduce the amount of collected data that is sent to the server). Additionally, the developer may specify that data collected will be stored in a database table with the calls PV_DBAddStringToRow and PV_DBAddIntToRow. Thus, the developer is provided great flexibility in specifying what data will be collected and how the data will be available.
- END-HOOK is the mechanism in Windows through which data is collected after the PUT terminates or crashes.
- information regarding the hardware, operating system, PUT e.g., version number
- this information is automatically collected with a single API call, PV_Start.
- the data is sent to the server at step 324 .
- the data may be analyzed.
- the data may be analyzed to fix bugs in the PUT, track feature utilization, optimize execution of the PUT, and the like.
- FIG. 5 illustrates a mechanism operating systems utilize to access routines in a system library.
- a call table 402 is kept in memory and associates system calls to routines in a system library 404 .
- a pointer indicates the routine in the system library that should be executed for the call.
- one call in the table would be the exit( ) call which would then result in executing a routine in the system library that exits or terminates the current process (with exit codes).
- the call table is also called the Windows system table and the system library may be called the Windows run-time DLL.
- FIG. 6 illustrates utilizing hooks to intercept system calls and PV API calls.
- a preferred embodiment of the invention intercepts the calls in the call table.
- a call table 452 is modified utilizing hooks to redirect the system calls to a PV library 454 .
- the PV library includes routines that include statements to facilitate remote monitoring of PUT execution.
- the routines in the PV library may also call routines in a system library 456 .
- the PV library is a Windows DLL.
- PV API calls are also added to call table 452 so that the appropriate routines in the PV library will be called.
- FIG. 6 shows that a PV API call PV_EndRunNow may cause the execution of the END_HOOK routine in the PV library.
- the PV_EndRunNow terminates the data collection on the client but allows the PUT to continue execution.
- FIG. 7 is a table of types of end-run-conditions for PUTs and the information that may be available in each case. Correctly identifying and reporting the way a PUT finished execution provides significant information to a developer. In a preferred embodiment, there are seven ways in which a PUT may stop execution (which are shown in the table of FIG. 7 ):
- All of the above end-of-run types except for 4. would pass through the modified call table.
- the information available indicates the information the present invention may analyze and include in the data collected that will be sent to the server.
- FIG. 8 is a high level flowchart of a process of end-of-run processing of a PUT.
- an end-of-run i.e., the end of data collection except for the final data collection for the end-of-run
- the routine END_HOOK is executed in the PV library at step 502 .
- the present invention includes a default for handing the end of run. By default the present invention automatically intercepts and reports end-of-run instances as follows.
- the PUT run is classified.
- the PUT run is classified as either a normal or abnormal run.
- an abnormal run is defined as a PUT that terminates with an uncaught exception or with a caught exception followed by a non-zero exit code.
- an abnormal run is defined as a PUT that terminates with an uncaught signal or exits with a non-zero exit code.
- Data is collected for the end-of-run at step 506 .
- information regarding the hardware, operating system, PUT e.g., version number
- user identifier e.g., user identifier
- PUT start time e.g., PUT start time
- PUT execution duration e.g., exit code
- exit exception e.g., exit exception
- stack information of the client may be collected for analysis on the server.
- the collected data is sent to the server.
- the server may then remotely analyze the data it receives. If the end of the PUT is reached at step 510 , the PUT is exited at step 512 . Otherwise, the PUT continues execution at step 514 .
- the collected data is automatically transmitted to the server without requiring the client to issue a command to send the collected data.
- the present invention provides a default mechanism for handling end-of-run situations, it also allows the developer to customize end-of-run processing.
- the PV API PV_RegisterEndHook allows a callback function to be defined that will be utilized instead of the default end-of-run processing.
- the custom END_HOOK processing is shown as step 516 in FIG. 8 .
- FIG. 9 is a high level flowchart of a process of performing remote debugging of a PUT on the server. Some of the steps that may be utilized are not shown in the figure. For example, it is not shown that the PUT is linked into an executable program. However, these steps will be readily apparent to one of skill in the art.
- the PUT is compiled with the source code including PV API calls to collect data for remote debugging.
- a module map is created during compilation and it is stored at step 554 .
- the module map is essentially a table that for each module in the PUT source code contains the address and offset of every function in the module.
- the module map is stored on nonvolatile storage (e.g., a hard drive) on the server.
- the executable PUT is sent to the client at step 556 .
- the PUT is executed at step 558 .
- the END_HOOK directs the client save both the call stack and the module list at step 560 .
- call stack is a list of addresses of function calls that were sequentially invoked during the PUT execution. The call stack is therefore generated while the PUT runs.
- the module list is a list of modules, including modules in the executable and any DLLs, along with the base address and size of each module.
- the module list is also created while the PUT runs.
- the client generates a module name/relative virtual address (RVA) list.
- the module name/RVA list is generated from the call stack and the module list.
- the module name/RVA list shows the sequence of function calls as a list of module names and relative offsets into each module. Typically, the module name/RVA list is generated during end-of-run processing.
- the module name/RVA list is sent to the server along with any other collected data at step 564 .
- a symbolic call stack is generated from the module map and the module name/RVA list at step 566 .
- the symbolic call stack is the sequence of functions calls including the module name, function name, and offset into the function for each call.
- the PUT may be remotely debugged on the server at step 568 .
- the present invention also reports uniqueness of the call stacks so that a developer may more quickly determine if the same problem is occurring on other clients' computers.
- FIG. 10 is a high level flowchart of a process of remotely upgrading the version of a PUT.
- the present invention also provides bidirectional communication between the server and the client.
- the developer may inform the client of upgrades and/or automatically have new software (e.g., new products, versions or patches) downloaded onto the client's machine.
- step 602 shows a PUT running on the client computer.
- a PV API call e.g., PV_Start
- the server receives the PUT version number and determines if the version is current at step 606 . If the version is not current, the current version (or a patch) may be downloaded to the client at step 608 . Additionally, the client may be queried as to whether it is desirable to get an upgrade in the event that they would prefer to retain the older version for any number of reasons (e.g., stability).
- the PUT continues execution at step 610 . Utilizing this process, the developer is able to accurately track which clients are running what versions of software. Additionally, as the developer is able to more quickly upgrade older versions, the testing of the program is more efficient as clients do not continue to run older versions reporting old problems or bugs.
- FIG. 11 is a block diagram of a bug tracker interfacing with a computer system of the present invention.
- the present invention may also interface with commercially available (or ones created by the developer) bug tracking software.
- a distributed system including a server computer 652 and multiple client computers 654 are shown.
- a bug tracking application 656 is designed to track the bugs that are found in the PUT and other information regarding the bug.
- a PV API call is utilized to collect the data for reporting the event to the bug tracking application.
- the bug tracking application may receive the information it requires directly from the clients or the clients may send information to the server with the server collecting the information.
- the server may then format the collected bug information and sends it to the bug tracking application.
- a PV API call may send collected data to more than one server if this is desirable for the developer.
- FIG. 12 is a block diagram of a computer system remotely monitoring PUTs in a multi-tasking or multi-threaded environment. It is desirable for developers to know how two or more programs (or threads) interact in a multi-tasking (or multi-threaded) environment. For example, it may be useful to know which application is the bottleneck, the sequence of application calls or what percentage of processor time is consumed by each application.
- a server computer 702 is in communication with a client computers 704 and 706 .
- Programs A and B are running on one client and program C is running on another client. Although A and B are described as programs, they may also be threads of the same program. Programs A, B and C are running concurrently and separate data is collected for each program (although the data may be stored on the same hard driver, it is shown separate for clarity).
- PV_Start returns a handle that may be utilized to uniquely identify a program or thread. The other PV API calls may receive this handle as a parameter so that data for each program or thread is collected together.
- the data collected for each program includes timestamps as to when the program began running. Additionally, information that indicates what program invoked another program may be collected. Once this collected data is received by the server, the server will be able to reconstruct the sequence of program execution on the clients.
- FIG. 13 is a block diagram of a computer system remotely monitoring computer programs incorporating code portions from multiple vendors.
- a PUT may include code portions or sections from multiple vendors. However, each vendor should receive information specific to the code that they produced. As shown a PUT 752 includes code portions from vendors A, B, C, and D.
- a PV_Start call is made which returns a handle specifying the appropriate vendor (e.g., A).
- Other PV API calls may then be sent to the appropriate handle specifying which vendors' code has generated the call and in which file the collected data should be stored.
- data for each vendor may be collected and stored separately (although, of course, it may be on the same hard drive).
- the present invention may utilize object code processing that inserts the data collection instructions into the object code of the PUT.
- FIG. 14 shows an object code file augmented to include new data collecting instructions.
- a preexisting object code file 802 (“OLDFILE.O”) is augmented by an expansion means 804 to include data collecting instructions for the present invention.
- An augmented object code file 806 (“NEWFILE.O”).
- the expansion means is a general purpose computer like the one shown in FIG. 1 . As the expansion means operates on object code, remote monitoring may be performed on the final executable product, not just those portions for which source code is available.
- the Microfiche Appendix includes source code for implementing an embodiment of the invention.
- the source is written in C++ and is designed for an IBM compatible computer running under one of the Windows family of operating systems.
- Appendix A a PureVision Unix & Windows API Specification
- Appendix B a PureVision Programmers' Guide
Abstract
Systems and methods for remotely monitoring the execution of computer programs are provided. Monitoring instructions are added the computer program so that during execution of the program, data may be collected regarding the program execution. The collected data may be automatically sent to a remote system or site for analysis. The monitoring instructions create little or no performance impact on the client yet provide valuable information to the developer of the program. Additionally, the monitoring instructions may be changes during computer program development.
Description
- A portion of the disclosure of this patent document contains material which is subject to copyright protection. The copyright owner has no objection to the xerographic reproduction by anyone of the patent document or the patent disclosure in exactly the form it appears in the Patent and Trademark Office patent file or records, but otherwise reserves all copyright rights whatsoever.
- The Microfiche Appendix (17 fiche with total of 1027 frames) includes source code for implementing an embodiment of the invention.
- The present invention is related to remote monitoring of computer programs and, more particularly, to a adding remote monitoring instructions to a computer program so that the execution of the computer program may be monitored at a remote site.
- As computer systems increasingly become more powerful and complex, so too do the computer programs that operate upon these computer systems. The increased complexity has resulted in much longer development times. Currently, computer programs take months and sometimes years to progress from pre-alpha through beta and final release.
- Developers have long realized that when a computer program is very complex, it is more efficient to have customers run the computer program (typically beta versions) so that the full functionality of the computer program in different environments may be exercised. Few developers have the people, machines and time to do the testing that may be provided by their customers.
- There are many problems that are presented with beta testing computer programs. Many of the problems revolve around the fact that the developer is at a remote site from the customers. At the remote site, it is difficult for the developer to know what is happening on a customer's computer system. Most customers do not have the expertise or resources to effectively convey problems to the developer. Without adequate information, it may be nearly impossible for a developer to correct a problem.
- The preceding is just one of the problems presented to a developer that is trying to develop a computer program that is running at a customer's site. Other problems include customers having platform differences, dealing with the evolving computer program through to final release, upgrading customers' computer programs, tracking bugs, analyzing multi-tasking or multi-threaded applications, and developing multi-vendor applications just to name a few.
- The present invention provides innovative systems and methods for remotely monitoring the execution of computer programs. Monitoring instructions (or data collecting instructions) are added the computer program so that during execution of the program, data may be collected regarding the program execution. The collected data may be automatically sent to a remote system or site for analysis. The present invention creates little or no performance impact on the client yet provides valuable information to the developer of the program.
- In one embodiment, the present invention provides a method of remotely monitoring execution of a computer program in a computer system, comprising the steps of: modifying the computer program to include at least one monitoring instruction; executing the computer program; the at least one monitoring instruction collecting data regarding the execution of the computer program; and sending the collected data to a remote system.
- In another embodiment, the present invention provides a distributed computer system, comprising: a server computer; a client computer in communication with the server computer; and a computer program running on the client computer that includes monitoring instructions that collect and send data regarding execution of the computer program to the server computer.
- In another embodiment, the present invention provides a computer program product for remotely monitoring execution of a computer program, comprising: a computer readable storage medium storing the computer program comprising: code that calls at least one monitoring instruction, the at least one monitoring instruction collecting data regarding the execution of the computer program; and code that sends the collected data to a remote system
- Other features and advantages of the present invention will become apparent upon a perusal of the remaining portions of the specification and drawings.
-
FIG. 1 illustrates an example of a computer system used to execute the software of the present invention; -
FIG. 2 shows a system block diagram of a typical computer system used to execute the software of the present invention; -
FIG. 3 is a block diagram of a distributed computer system where a server computer may remotely monitor execution of computer programs on client computers; -
FIG. 4 is a high level flowchart of a process of remotely monitoring execution of a computer program; -
FIG. 5 illustrates a mechanism operating systems utilize to access routines in a system library; -
FIG. 6 illustrates utilizing hooks to intercept systems calls and PV API calls; -
FIG. 7 is a table of types of end-run-conditions for computer programs and the information that may be available; -
FIG. 8 is a high level flowchart of a process of end-of-run processing of a computer program; -
FIG. 9 is a high level flowchart of a process of performing remote debugging of a computer program; -
FIG. 10 is a high level flowchart of a process of remotely upgrading the version of a computer program; -
FIG. 11 is a block diagram of a bug tracker interfacing with a computer system of the present invention; -
FIG. 12 is a block diagram of a computer system remotely monitoring computer programs in a multi-tasking or multi-threaded environment; -
FIG. 13 is a block diagram of a computer system remotely monitoring computer programs incorporating portions from multiple vendors; and -
FIG. 14 shows an object code file augmented to include new data collection instructions. - The present invention provides a remote data collection facility that may be utilized for developers to monitor a program under test (PUT). A PUT is therefore a computer program or application that has been distributed to a client (or other site) for which the developer would like to monitor the execution remotely. This remote monitoring may be performed from pre-alpha through beta and final release. In a preferred embodiment, the present invention is incorporated in PureVision (PV) which is available from Pure Software Inc., Sunnyvale, Calif.
- In the description that follows, the present invention will be described in reference to an IBM compatible computer running under one of the Windows family of operating systems. The present invention, however, is not limited to any particular computer architecture or operating system. Therefore, the description the embodiments that follow is for purposes of illustration and not limitation.
-
FIG. 1 illustrates an example of a computer system used to execute the software of the present invention.FIG. 1 shows acomputer system 1 which includes amonitor 3,screen 5,cabinet 7,keyboard 9, and mouse 11. Mouse 11 may have one or more buttons such asmouse buttons 13.Cabinet 7 houses a CD-ROM drive 15, a system memory and a hard drive (seeFIG. 2 ) which may be utilized to store and retrieve software programs incorporating code that implements the present invention, data for use with the present invention, and the like. Although a CD-ROM 17 is shown as an exemplary computer readable storage medium, other computer readable storage media including floppy disks, tape, flash memory, system memory, and hard drives may be utilized.Cabinet 7 also houses familiar computer components (not shown) such as a central processor, system memory, hard disk, and the like. -
FIG. 2 shows a system block diagram ofcomputer system 1 used to execute the software of the present invention. As inFIG. 1 ,computer system 1 includesmonitor 3 andkeyboard 9.Computer system 1 further includes subsystems such as acentral processor 102,system memory 104, I/O controller 106,display adapter 108, removable disk 112 (e.g., CD-ROM drive), fixed disk 116 (e.g., hard drive),network interface 118, andspeaker 120. Other computer systems suitable for use with the present invention may include additional or fewer subsystems. For example, another computer system could include more than one processor 102 (i.e., a multi-processor system) or a cache memory. - Arrows such as 122 represent the system bus architecture of
computer system 1. However, these arrows are illustrative of any interconnection scheme serving to link the subsystems. For example, a local bus could be utilized to connect the central processor to the system memory and display adapter.Computer system 1 shown inFIG. 2 is but an example of a computer system suitable for use with the present invention. Other configurations of subsystems suitable for use with the present invention will be readily apparent to one of ordinary skill in the art. -
FIG. 3 is a block diagram of a distributed computer system where a server computer may remotely monitor execution of PUTs on client computers. Aserver computer 202 is in communication with multiple clients, of whichclients client 208. - The computer system that monitors a PUT will be designated a “server” and a computer system on which the PUT executes will be designed a “client.” For simplicity, the server computer will be described as the computer system that performs development of the PUT and remote monitoring of execution of the PUT. However, the development and remote monitoring may be performed on entirely different computer systems and at different locations.
- A client executes the PUT which includes additional monitoring instructions for collecting data regarding the PUT execution. The collected data may be stored locally on the client until it is transferred to the server for analysis. The collected data is sent or transferred to the server via a transport mechanism.
- The present invention provides a platform independent application programming interface (API) for directing the data collection for an executing PUT. As shown,
client 204 is operating under the Unix operating system. In contrast,client 206 is operating under one of the family of Windows operating systems. The API of the present invention (PV API) is portable as a same set of API calls apply to PUTs running on both operating systems. This functionality allows developers to create a single source tree across different platforms. Although platform-specific API calls may be provided, these calls will be ignored if the platform is incompatible. -
FIG. 4 is a high level flowchart of a process of remotely monitoring execution of a PUT. The flowchart is divided into a server-side and a client-side to indicate on which computer systems the steps are performed. Atstep 302, the PV API is installed on the server computer for remotely monitoring the PUT. In a preferred embodiment, the PV API calls are stored in a dynamic-link library (DLL). As will be discussed in more detail in reference toFIGS. 5 and 6 , hooks that are available in Windows may be utilized to intercept the system calls. A similar mechanism may be utilized for Unix systems. - At least one PV API call is placed in the PUT source code at
step 304. The PV_Start call may be added to the PUT source code to start monitoring of the PUT during execution. Data will be collected regarding the execution and, in a preferred embodiment, the collected data will be automatically sent to the server. The data is typically collected until the PUT finishes execution. Other PV API calls may be utilized to customize the data collection. Thus, developers may dynamically change the data that will be collected over the application development cycle from pre-alpha to beta through final release. - At
step 306, the PUT is compiled and linked into an executable computer program. After the PUT is a computer program that incorporates remote monitoring instructions, the PUT is sent to the client. The PUT may be sent to the client in any number of ways including networks and magnetic media like floppies. - Once the PUT is installed on the client, the PUT is executed at
step 310. Although multi-tasking and multi-threaded applications perform tasks in parallel, each task or thread essentially operates by executing statements in sequential order. Accordingly, in discussing this figure, all applications will be generalized to this sequential execution of statements. - At
step 312, the next statement is retrieved. The client then determines if the statement is a PV API call atstep 314. If it is not, the PUT statement is executed atstep 316. A PUT statement is basically any statement that is not a PV API call for remote monitoring. - The client calls the PV API specified by the statement at
step 318. There are numerous types of PV API calls that may be called including calls that perform the following: -
- starting and ending a PUT run
- controlling the amount of data being collected
- logging unstructured data
- inserting simple per-run data
- inserting complex data fields
- platform-specific functions
- The PV API calls allow the developer to specify characteristics of the data that will be collected during a PUT run. For example, in addition to the developer being able to turn data collection on and off at locations in the PUT with PV_On and PV_Off, the developer is also able to specify that data collected under a given type should be discarded (e.g., to reduce the amount of collected data that is sent to the server). Additionally, the developer may specify that data collected will be stored in a database table with the calls PV_DBAddStringToRow and PV_DBAddIntToRow. Thus, the developer is provided great flexibility in specifying what data will be collected and how the data will be available.
- At
step 320, it is determined whether the PUT is finished executing. If it is not, execution resumes atstep 312 where the next statement is retrieved. Otherwise, the client performs END-HOOK data collection atstep 322. In a preferred embodiment, END-HOOK is the mechanism in Windows through which data is collected after the PUT terminates or crashes. In order to aid the developer in tracking down crashes, information regarding the hardware, operating system, PUT (e.g., version number), and the like may be automatically collected to indicate the environment of the client. In a preferred embodiment, this information is automatically collected with a single API call, PV_Start. - Once the data is collected regarding the PUT execution, the data is sent to the server at
step 324. Once at the server, the data may be analyzed. The data may be analyzed to fix bugs in the PUT, track feature utilization, optimize execution of the PUT, and the like. -
FIG. 5 illustrates a mechanism operating systems utilize to access routines in a system library. A call table 402 is kept in memory and associates system calls to routines in asystem library 404. For each call, a pointer indicates the routine in the system library that should be executed for the call. For example, one call in the table would be the exit( ) call which would then result in executing a routine in the system library that exits or terminates the current process (with exit codes). In Windows, the call table is also called the Windows system table and the system library may be called the Windows run-time DLL. These structures are also available in Unix and other operating systems. -
FIG. 6 illustrates utilizing hooks to intercept system calls and PV API calls. Utilizing hooks, a preferred embodiment of the invention intercepts the calls in the call table. A call table 452 is modified utilizing hooks to redirect the system calls to aPV library 454. The PV library includes routines that include statements to facilitate remote monitoring of PUT execution. The routines in the PV library may also call routines in asystem library 456. In a preferred embodiment, the PV library is a Windows DLL. - Additionally, PV API calls are also added to call table 452 so that the appropriate routines in the PV library will be called. As an example,
FIG. 6 shows that a PV API call PV_EndRunNow may cause the execution of the END_HOOK routine in the PV library. The PV_EndRunNow terminates the data collection on the client but allows the PUT to continue execution. -
FIG. 7 is a table of types of end-run-conditions for PUTs and the information that may be available in each case. Correctly identifying and reporting the way a PUT finished execution provides significant information to a developer. In a preferred embodiment, there are seven ways in which a PUT may stop execution (which are shown in the table ofFIG. 7 ): - 1. PUT Normal Exit—exiting by invoking a member of the exit family of routines or returning from the main routine
- 2. PUT exec( )—invoking a different executable by successfully calling exec
- 3. PUT Exception Caught by Developer—catching an exception or signal in an exception handler and invoking exit from the handler
- 4. PUT Exception Uncaught by Developer—encountering an uncaught exception
- 5. PUT Dies via uncatchable event—encountering an uncatchable event (e.g., stack overflow or kill process)
- 6. Developer ends run before PUT ends—PV API call to stop data collection (PV_EndRunNow)
- 7. PureVision Dies via an unexpected event—the data collection software of the present invention halts (e.g., power off or internal error)
- All of the above end-of-run types except for 4. would pass through the modified call table. The information available indicates the information the present invention may analyze and include in the data collected that will be sent to the server.
-
FIG. 8 is a high level flowchart of a process of end-of-run processing of a PUT. When an end-of-run (i.e., the end of data collection except for the final data collection for the end-of-run) occurs, the routine END_HOOK is executed in the PV library atstep 502. The present invention includes a default for handing the end of run. By default the present invention automatically intercepts and reports end-of-run instances as follows. - At
step 504, the PUT run is classified. The PUT run is classified as either a normal or abnormal run. In Windows, an abnormal run is defined as a PUT that terminates with an uncaught exception or with a caught exception followed by a non-zero exit code. Similarly, on Unix an abnormal run is defined as a PUT that terminates with an uncaught signal or exits with a non-zero exit code. - Data is collected for the end-of-run at
step 506. As mentioned earlier, information regarding the hardware, operating system, PUT (e.g., version number), user identifier, PUT start time, PUT execution duration, exit code, exit exception, and the like may be automatically collected to indicate the environment of the client at an end-of-run. Additionally, in the event of an abnormal run, stack information of the client may be collected for analysis on the server. - At
step 508, the collected data is sent to the server. The server may then remotely analyze the data it receives. If the end of the PUT is reached atstep 510, the PUT is exited atstep 512. Otherwise, the PUT continues execution atstep 514. In a preferred embodiment, the collected data is automatically transmitted to the server without requiring the client to issue a command to send the collected data. - Although the present invention provides a default mechanism for handling end-of-run situations, it also allows the developer to customize end-of-run processing. The PV API PV_RegisterEndHook allows a callback function to be defined that will be utilized instead of the default end-of-run processing. The custom END_HOOK processing is shown as
step 516 inFIG. 8 . -
FIG. 9 is a high level flowchart of a process of performing remote debugging of a PUT on the server. Some of the steps that may be utilized are not shown in the figure. For example, it is not shown that the PUT is linked into an executable program. However, these steps will be readily apparent to one of skill in the art. - At
step 552, the PUT is compiled with the source code including PV API calls to collect data for remote debugging. A module map is created during compilation and it is stored atstep 554. The module map is essentially a table that for each module in the PUT source code contains the address and offset of every function in the module. Typically, the module map is stored on nonvolatile storage (e.g., a hard drive) on the server. - The executable PUT is sent to the client at
step 556. On the client-side, the PUT is executed atstep 558. When an end-of-run is encountered, the END_HOOK directs the client save both the call stack and the module list atstep 560. call stack is a list of addresses of function calls that were sequentially invoked during the PUT execution. The call stack is therefore generated while the PUT runs. - The module list is a list of modules, including modules in the executable and any DLLs, along with the base address and size of each module. The module list is also created while the PUT runs.
- At
step 562, the client generates a module name/relative virtual address (RVA) list. The module name/RVA list is generated from the call stack and the module list. The module name/RVA list shows the sequence of function calls as a list of module names and relative offsets into each module. Typically, the module name/RVA list is generated during end-of-run processing. - The module name/RVA list is sent to the server along with any other collected data at
step 564. On the server, a symbolic call stack is generated from the module map and the module name/RVA list atstep 566. The symbolic call stack is the sequence of functions calls including the module name, function name, and offset into the function for each call. Utilizing the symbolic call stack, the PUT may be remotely debugged on the server atstep 568. In a preferred embodiment, the present invention also reports uniqueness of the call stacks so that a developer may more quickly determine if the same problem is occurring on other clients' computers. -
FIG. 10 is a high level flowchart of a process of remotely upgrading the version of a PUT. The present invention also provides bidirectional communication between the server and the client. The developer may inform the client of upgrades and/or automatically have new software (e.g., new products, versions or patches) downloaded onto the client's machine. - As an example, step 602 shows a PUT running on the client computer. During execution, a PV API call (e.g., PV_Start) sends the PUT version number to the server at
step 604. The server receives the PUT version number and determines if the version is current atstep 606. If the version is not current, the current version (or a patch) may be downloaded to the client atstep 608. Additionally, the client may be queried as to whether it is desirable to get an upgrade in the event that they would prefer to retain the older version for any number of reasons (e.g., stability). - Whether a new version is downloaded or not, the PUT continues execution at
step 610. Utilizing this process, the developer is able to accurately track which clients are running what versions of software. Additionally, as the developer is able to more quickly upgrade older versions, the testing of the program is more efficient as clients do not continue to run older versions reporting old problems or bugs. -
FIG. 11 is a block diagram of a bug tracker interfacing with a computer system of the present invention. The present invention may also interface with commercially available (or ones created by the developer) bug tracking software. A distributed system including aserver computer 652 andmultiple client computers 654 are shown. - A
bug tracking application 656 is designed to track the bugs that are found in the PUT and other information regarding the bug. When an event occurs during execution of the PUT that necessitates reporting (e.g., a bug), a PV API call is utilized to collect the data for reporting the event to the bug tracking application. - The bug tracking application may receive the information it requires directly from the clients or the clients may send information to the server with the server collecting the information. The server may then format the collected bug information and sends it to the bug tracking application. Additionally, a PV API call may send collected data to more than one server if this is desirable for the developer.
-
FIG. 12 is a block diagram of a computer system remotely monitoring PUTs in a multi-tasking or multi-threaded environment. It is desirable for developers to know how two or more programs (or threads) interact in a multi-tasking (or multi-threaded) environment. For example, it may be useful to know which application is the bottleneck, the sequence of application calls or what percentage of processor time is consumed by each application. - As shown, a
server computer 702 is in communication with aclient computers - In a preferred embodiment, the data collected for each program includes timestamps as to when the program began running. Additionally, information that indicates what program invoked another program may be collected. Once this collected data is received by the server, the server will be able to reconstruct the sequence of program execution on the clients.
-
FIG. 13 is a block diagram of a computer system remotely monitoring computer programs incorporating code portions from multiple vendors. A PUT may include code portions or sections from multiple vendors. However, each vendor should receive information specific to the code that they produced. As shown aPUT 752 includes code portions from vendors A, B, C, and D. When the code for a specific vendor is entered, a PV_Start call is made which returns a handle specifying the appropriate vendor (e.g., A). Other PV API calls may then be sent to the appropriate handle specifying which vendors' code has generated the call and in which file the collected data should be stored. Thus, data for each vendor may be collected and stored separately (although, of course, it may be on the same hard drive). - Although the above has described modifying the source code to include PV API calls for data collection, the present is not limited to any specific method. For example, the present invention may utilize object code processing that inserts the data collection instructions into the object code of the PUT.
-
FIG. 14 shows an object code file augmented to include new data collecting instructions. A preexisting object code file 802 (“OLDFILE.O”) is augmented by an expansion means 804 to include data collecting instructions for the present invention. An augmented object code file 806 (“NEWFILE.O”). Typically, the expansion means is a general purpose computer like the one shown inFIG. 1 . As the expansion means operates on object code, remote monitoring may be performed on the final executable product, not just those portions for which source code is available. - The Microfiche Appendix includes source code for implementing an embodiment of the invention. The source is written in C++ and is designed for an IBM compatible computer running under one of the Windows family of operating systems.
- Appendix A, a PureVision Unix & Windows API Specification, and Appendix B, a PureVision Programmers' Guide, are filed herewith as part of the application and are incorporated by reference for all purposes.
- While the above is a complete description of the preferred embodiments of the invention, various alternatives, modifications and equivalents may be used. It should be evident that the present invention is equally applicable by making appropriate modifications to the embodiments described above. Therefore, the above description should not be taken as limiting the scope of the invention which is defined by the metes and bounds of the appended claims.
Claims (38)
1-39. (canceled)
40. A method of remotely monitoring execution of a computer program, the method comprising:
compiling a computer program to include at least one monitoring instruction, the at least one monitoring instruction directing collection of data regarding execution of the computer program;
transmitting the computer program to a remote computer system; and
receiving the data collected at the remote computer system, the data regarding execution of the computer program at the remote computer system.
41. The method of claim 40 , further comprising storing the collected data to a computer-readable medium, the computer-readable medium being one of a CD-ROM, floppy drive, tape, flash memory, system memory, and hard drive.
42. The method of claim 40 , wherein the monitoring instruction directs the remote computer system to collect the data regarding execution of the computer program.
43. The method of claim 40 , wherein the monitoring instruction directs the remote computer system to transmit the data to a server.
44. The method of claim 43 , wherein the monitoring instruction directs the remote computer system to transmit the data automatically upon completion of execution of the program.
45. The method of claim 43 , wherein the remote computer system executes the program implementing a first computing platform, and the server collects the data implementing a second platform, the first and second platforms being distinct.
46. The method of claim 40 , further comprising classifying execution of the program as normal or abnormal.
47. The method of claim 40 , further comprising analyzing the data.
48. The method of claim 40 , further comprising providing the collected data to an application programming interface.
49. The method of claim 48 , wherein the application programming interface is platform independent.
50. The method of claim 40 , further comprising installing the monitoring instruction into source code of the computer program.
51. The method of claim 50 , wherein installing the monitoring instruction includes installing a plurality of calls into the source code, the calls controlling data collection during execution of the computer program.
52. The method of claim 40 , further comprising generating and storing a module map, the module map indicating functions in each module in the computer program.
53. The method of claim 52 , wherein the monitoring instruction directs the remote computer system to generate a module name and relative virtual address list.
54. The method of claim 53 , wherein receiving the collected data includes collecting the module name and relative virtual address list from the remote computer system.
55. The method of claim 54 , further comprising generating a symbolic call stack from the module map and module name and relative virtual address list.
56. The method of claim 55 , further comprising debugging the computer program using the symbolic call stack.
57. A computer-readable medium storing computer readable code that, when executed by a computer system, cause the system to:
install a monitoring instruction into source code of a computer program;
compile the computer program based on the source code, the computer program incorporating the monitoring instruction;
transmit the computer program to a remote computer system; and
collect data from the remote computer system, the data regarding execution of the computer program at the remote computer system.
58. A distributed computing system comprising:
a server computer configured to install a monitoring instruction into a computer program, the monitoring instruction instructing a computer to collect data regarding execution of the computer program; and
a client computer configured to execute the computer program and transmit the data to the server computer.
59. An apparatus for remotely monitoring execution of a computer program, the apparatus comprising:
means for compiling a computer program to include at least one monitoring instruction, the at least one monitoring instruction directing collection of data regarding execution of the computer program;
means for transmitting the computer program to a remote computer system; and
means for receiving the data collected at the remote computer system, the data regarding execution of the computer program at the remote computer system.
60. An apparatus for remotely monitoring execution of a computer program, the apparatus comprising:
a processor for compiling a computer program to include at least one monitoring instruction, the at least one monitoring instruction directing collection of data regarding execution of the computer program;
a network interface for transmitting the computer program to a remote computer system; and
a storage device for storing the data collected at the remote computer system, the data regarding execution of the computer program at the remote computer system.
61. The apparatus of claim 60 , wherein the storage device is a computer-readable medium, the computer-readable medium being one of a CD-ROM, floppy drive, tape, flash memory, system memory, and hard drive.
62. The apparatus of claim 60 , wherein the monitoring instruction directs the remote computer system to collect the data regarding execution of the computer program.
63. The apparatus of claim 60 , wherein the monitoring instruction directs the remote computer system to transmit the data to a server.
64. The apparatus of claim 63 , wherein the monitoring instruction directs the remote computer system to transmit the data automatically upon completion of execution of the program.
65. The apparatus of claim 63 , wherein the remote computer system executes the program implementing a first computing platform, and the server collects the data implementing a second platform, the first and second platforms being distinct.
66. The apparatus of claim 60 , wherein the processor classifies execution of the program as normal or abnormal.
67. The apparatus of claim 60 , wherein the processor analyzes the data.
68. The apparatus of claim 60 , wherein the processor operates an application programming interface.
69. The apparatus of claim 68 , wherein the application programming interface is platform independent.
70. The apparatus of claim 60 , wherein the processor installs the monitoring instruction into source code of the computer program.
71. The apparatus of claim 70 , wherein the monitoring instruction includes a plurality of calls into the source code, the calls controlling data collection during execution of the computer program.
72. The apparatus of claim 60 , wherein the processor generates and stores a module map, the module map indicating functions in each module in the computer program.
73. The apparatus of claim 72 , wherein the monitoring instruction directs the remote computer system to generate a module name and relative virtual address list.
74. The apparatus of claim 73 , wherein the collected data includes the module name and relative virtual address list from the remote computer system.
75. The apparatus of claim 74 , wherein the processor generates a symbolic call stack from the module map and module name and relative virtual address list.
76. The apparatus of claim 75 , wherein the processor enables debugging of the computer program using the symbolic call stack.
Priority Applications (1)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
US11/986,310 US20080147853A1 (en) | 1995-06-02 | 2007-11-20 | Remote monitoring of computer programs |
Applications Claiming Priority (6)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
US46051695A | 1995-06-02 | 1995-06-02 | |
US08/657,106 US5918004A (en) | 1995-06-02 | 1996-06-03 | Remote monitoring of computer programs |
US09/340,862 US6263457B1 (en) | 1995-06-02 | 1999-06-28 | Remote monitoring of computer programs |
US09/907,510 US6634001B2 (en) | 1995-06-02 | 2001-07-16 | Remote monitoring of computer programs |
US10/642,387 US7299455B2 (en) | 1995-06-02 | 2003-08-15 | Remote monitoring of computer programs |
US11/986,310 US20080147853A1 (en) | 1995-06-02 | 2007-11-20 | Remote monitoring of computer programs |
Related Parent Applications (1)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
US10/642,387 Continuation US7299455B2 (en) | 1995-06-02 | 2003-08-15 | Remote monitoring of computer programs |
Publications (1)
Publication Number | Publication Date |
---|---|
US20080147853A1 true US20080147853A1 (en) | 2008-06-19 |
Family
ID=23829028
Family Applications (5)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
US08/657,106 Expired - Lifetime US5918004A (en) | 1995-06-02 | 1996-06-03 | Remote monitoring of computer programs |
US09/340,862 Expired - Lifetime US6263457B1 (en) | 1995-06-02 | 1999-06-28 | Remote monitoring of computer programs |
US09/907,510 Expired - Lifetime US6634001B2 (en) | 1995-06-02 | 2001-07-16 | Remote monitoring of computer programs |
US10/642,387 Expired - Fee Related US7299455B2 (en) | 1995-06-02 | 2003-08-15 | Remote monitoring of computer programs |
US11/986,310 Abandoned US20080147853A1 (en) | 1995-06-02 | 2007-11-20 | Remote monitoring of computer programs |
Family Applications Before (4)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
US08/657,106 Expired - Lifetime US5918004A (en) | 1995-06-02 | 1996-06-03 | Remote monitoring of computer programs |
US09/340,862 Expired - Lifetime US6263457B1 (en) | 1995-06-02 | 1999-06-28 | Remote monitoring of computer programs |
US09/907,510 Expired - Lifetime US6634001B2 (en) | 1995-06-02 | 2001-07-16 | Remote monitoring of computer programs |
US10/642,387 Expired - Fee Related US7299455B2 (en) | 1995-06-02 | 2003-08-15 | Remote monitoring of computer programs |
Country Status (4)
Country | Link |
---|---|
US (5) | US5918004A (en) |
EP (1) | EP0830611A4 (en) |
CA (1) | CA2224689C (en) |
WO (1) | WO1996038733A1 (en) |
Cited By (8)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US20070038896A1 (en) * | 2005-08-12 | 2007-02-15 | International Business Machines Corporation | Call-stack pattern matching for problem resolution within software |
US20090328026A1 (en) * | 2007-03-20 | 2009-12-31 | Fujitsu Limited | Update system, program execution device, and computer program |
US20100128866A1 (en) * | 2008-11-26 | 2010-05-27 | Microsoft Corporation | Modification of system call behavior |
US20110107307A1 (en) * | 2009-10-30 | 2011-05-05 | International Business Machines Corporation | Collecting Program Runtime Information |
US20130185600A1 (en) * | 2012-01-12 | 2013-07-18 | International Business Machines Corporation | Thread based dynamic data collection |
US9064046B1 (en) * | 2006-01-04 | 2015-06-23 | Emc Corporation | Using correlated stack traces to determine faults in client/server software |
CN104735162A (en) * | 2015-04-10 | 2015-06-24 | 上海自仪泰雷兹交通自动化系统有限公司 | Remote log collection method used for security encryption devices of rail transit signal system |
US11177972B2 (en) * | 2016-07-29 | 2021-11-16 | International Business Machines Corporation | Event notification |
Families Citing this family (168)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
EP0830611A4 (en) | 1995-06-02 | 2007-05-09 | Cisco Systems Inc | Remote monitoring of computer programs |
US6134601A (en) * | 1996-06-17 | 2000-10-17 | Networks Associates, Inc. | Computer resource management system |
US6526456B1 (en) * | 1996-07-01 | 2003-02-25 | David Ian Allan | Distribution and controlled use of software products |
PL334802A1 (en) * | 1997-01-09 | 2000-03-13 | Media Metrix | Method of remotely monitoring the access to files in a public computer network |
US6654879B1 (en) * | 1997-01-30 | 2003-11-25 | Northbrook Services | Method and apparatus for analyzing code for out-of-range data involving base and seed tables/lists |
WO1998037659A2 (en) * | 1997-02-24 | 1998-08-27 | Wildfire Communications, Inc. | Method and apparatus for offering additional product functions to a user |
US6553416B1 (en) * | 1997-05-13 | 2003-04-22 | Micron Technology, Inc. | Managing computer system alerts |
US6219711B1 (en) | 1997-05-13 | 2001-04-17 | Micron Electronics, Inc. | Synchronous communication interface |
US6425006B1 (en) | 1997-05-13 | 2002-07-23 | Micron Technology, Inc. | Alert configurator and manager |
US6134615A (en) | 1997-05-13 | 2000-10-17 | Micron Electronics, Inc. | System for facilitating the replacement or insertion of devices in a computer system through the use of a graphical user interface |
US6938245B1 (en) | 1997-10-29 | 2005-08-30 | Veritas Operating Corporation | Interactive debugging system with debug data base system |
US6145096A (en) * | 1998-05-06 | 2000-11-07 | Motive Communications, Inc. | Method, system and computer program product for iterative distributed problem solving |
US6219804B1 (en) * | 1998-08-05 | 2001-04-17 | International Business Machines Corporation | Debugging client server programs from third party workstations |
EP0990964A1 (en) * | 1998-09-28 | 2000-04-05 | Siemens Aktiengesellschaft | Method for operating an automatic device |
US6553507B1 (en) * | 1998-09-30 | 2003-04-22 | Intel Corporation | Just-in-time software updates |
US6694314B1 (en) | 1998-12-18 | 2004-02-17 | Motive Communications, Inc. | Technical support chain automation with guided self-help capability via a system-supplied search string |
US6615240B1 (en) | 1998-12-18 | 2003-09-02 | Motive Communications, Inc. | Technical support chain automation with guided self-help capability and option to escalate to live help |
US6477531B1 (en) | 1998-12-18 | 2002-11-05 | Motive Communications, Inc. | Technical support chain automation with guided self-help capability using active content |
US6593940B1 (en) * | 1998-12-23 | 2003-07-15 | Intel Corporation | Method for finding errors in multithreaded applications |
US6542898B1 (en) | 1999-05-12 | 2003-04-01 | Motive Communications, Inc. | Technical support chain automation with guided self-help capability using active content developed for specific audiences |
JP2001005693A (en) * | 1999-06-22 | 2001-01-12 | Nec Corp | System and method for automatically restoring fault and recording medium recording automatic fault restoration program |
DE19930660A1 (en) * | 1999-07-02 | 2001-01-11 | Siemens Ag | Process for monitoring or installing new program codes in an industrial plant |
US6615253B1 (en) * | 1999-08-31 | 2003-09-02 | Accenture Llp | Efficient server side data retrieval for execution of client side applications |
US6449739B1 (en) | 1999-09-01 | 2002-09-10 | Mercury Interactive Corporation | Post-deployment monitoring of server performance |
US6601190B1 (en) * | 1999-10-28 | 2003-07-29 | Hewlett-Packard Development Company, L.P. | Automatic capture and reporting of computer configuration data |
US6948175B1 (en) * | 1999-11-16 | 2005-09-20 | Ricoh Company, Ltd. | Method and system of remote diagnostic, control and information collection using a dynamic linked library |
US6539539B1 (en) * | 1999-11-16 | 2003-03-25 | Lucent Technologies Inc. | Active probes for ensuring software package compatibility |
US6477483B1 (en) | 2000-01-17 | 2002-11-05 | Mercury Interactive Corporation | Service for load testing a transactional server over the internet |
US6658598B1 (en) | 2000-02-17 | 2003-12-02 | Motive Communications, Inc. | Technical support chain automation with guided self-help capability using active content assertions |
US20020087949A1 (en) * | 2000-03-03 | 2002-07-04 | Valery Golender | System and method for software diagnostics using a combination of visual and dynamic tracing |
US6973489B1 (en) | 2000-03-21 | 2005-12-06 | Mercury Interactive Corporation | Server monitoring virtual points of presence |
JP2001265906A (en) * | 2000-03-23 | 2001-09-28 | Nec Corp | On-line real time monitoring system and on-line real time monitor business method |
US7251810B1 (en) * | 2000-04-26 | 2007-07-31 | Microsoft Corporation | Minimal instrumentation for lossless call profiling |
GB2367642B (en) * | 2000-05-27 | 2004-05-05 | Ibm | Performance profiling tool |
US6708333B1 (en) * | 2000-06-23 | 2004-03-16 | Microsoft Corporation | Method and system for reporting failures of a program module in a corporate environment |
US6658416B1 (en) * | 2000-07-10 | 2003-12-02 | International Business Machines Corporation | Apparatus and method for creating an indexed database of symbolic data for use with trace data of a computer program |
US6988263B1 (en) | 2000-07-10 | 2006-01-17 | International Business Machines Corporation | Apparatus and method for cataloging symbolic data for use in performance analysis of computer programs |
JP3716729B2 (en) * | 2000-09-27 | 2005-11-16 | セイコーエプソン株式会社 | User support |
US8312435B2 (en) | 2000-12-26 | 2012-11-13 | Identify Software Ltd. (IL) | System and method for conditional tracing of computer programs |
US6738911B2 (en) * | 2001-02-02 | 2004-05-18 | Keith Hayes | Method and apparatus for providing client-based network security |
US6792564B2 (en) * | 2001-03-01 | 2004-09-14 | International Business Machines Corporation | Standardized format for reporting error events occurring within logically partitioned multiprocessing systems |
US7185234B1 (en) * | 2001-04-30 | 2007-02-27 | Mips Technologies, Inc. | Trace control from hardware and software |
US7331050B2 (en) * | 2001-06-06 | 2008-02-12 | Intel Corporation | System and method for communicating information between application programs |
US7895350B1 (en) | 2001-07-05 | 2011-02-22 | Motive, Inc. | N-way data stream splitter |
US8473922B2 (en) * | 2001-09-19 | 2013-06-25 | Hewlett-Packard Development Company, L.P. | Runtime monitoring in component-based systems |
US6944793B1 (en) | 2001-10-29 | 2005-09-13 | Red Hat, Inc. | Method of remote monitoring |
US7003530B2 (en) * | 2002-03-22 | 2006-02-21 | General Motors Corporation | Algorithm for selecting audio content |
US7644392B2 (en) * | 2002-04-12 | 2010-01-05 | Telelogic Technologies North America, Inc. | System and method for active configuration management |
US20030226062A1 (en) * | 2002-06-03 | 2003-12-04 | Gender Thomas K. | System and method for testing response to asynchronous system errors |
JP4054616B2 (en) * | 2002-06-27 | 2008-02-27 | 株式会社日立製作所 | Logical computer system, logical computer system configuration control method, and logical computer system configuration control program |
US7937430B1 (en) | 2002-07-31 | 2011-05-03 | At&T Intellectual Property I, L.P. | System and method for collecting and transmitting data in a computer network |
US6792460B2 (en) * | 2002-10-02 | 2004-09-14 | Mercury Interactive Corporation | System and methods for monitoring application server performance |
US7386839B1 (en) | 2002-11-06 | 2008-06-10 | Valery Golender | System and method for troubleshooting software configuration problems using application tracing |
US20040128583A1 (en) * | 2002-12-31 | 2004-07-01 | International Business Machines Corporation | Method and system for monitoring, diagnosing, and correcting system problems |
CA2418670A1 (en) * | 2003-02-11 | 2004-08-11 | Ibm Canada Limited - Ibm Canada Limitee | Method and system for generating executable code for formatiing and printing complex data structures |
US8032866B1 (en) * | 2003-03-27 | 2011-10-04 | Identify Software Ltd. | System and method for troubleshooting runtime software problems using application learning |
US7185231B2 (en) * | 2003-05-14 | 2007-02-27 | Microsoft Corporation | Methods and systems for collecting, analyzing, and reporting software reliability and availability |
US20040249914A1 (en) * | 2003-05-21 | 2004-12-09 | Flocken Philip A. | Computer service using automated local diagnostic data collection and automated remote analysis |
US9069666B2 (en) * | 2003-05-21 | 2015-06-30 | Hewlett-Packard Development Company, L.P. | Systems and methods for controlling error reporting and resolution |
US20050015767A1 (en) * | 2003-07-01 | 2005-01-20 | Brian Nash | Operating system configuration tool |
US7194664B1 (en) * | 2003-09-08 | 2007-03-20 | Poon Fung | Method for tracing application execution path in a distributed data processing system |
US7721265B1 (en) | 2003-11-10 | 2010-05-18 | Cisco Technology, Inc. | Source code debugging method and apparatus for use in script testing environment |
US7739689B1 (en) * | 2004-02-27 | 2010-06-15 | Symantec Operating Corporation | Internal monitoring of applications in a distributed management framework |
US7398469B2 (en) * | 2004-03-12 | 2008-07-08 | United Parcel Of America, Inc. | Automated test system for testing an application running in a windows-based environment and related methods |
US7363615B2 (en) * | 2004-03-12 | 2008-04-22 | Autodesk, Inc. | Stack-based callbacks for diagnostic data generation |
US8255879B2 (en) * | 2004-05-17 | 2012-08-28 | Ca, Inc. | Method and apparatus for improving a software product |
US20050268112A1 (en) * | 2004-05-28 | 2005-12-01 | Microsoft Corporation | Managing spyware and unwanted software through auto-start extensibility points |
US7827539B1 (en) | 2004-06-25 | 2010-11-02 | Identify Software Ltd. | System and method for automated tuning of program execution tracing |
US7426661B2 (en) * | 2004-07-20 | 2008-09-16 | Softricity, Inc. | Method and system for minimizing loss in a computer application |
KR100605017B1 (en) | 2004-08-20 | 2006-07-28 | 학교법인 울산공업학원 | RMON agent system with dynamic reconfiguration capability |
US8150704B2 (en) * | 2004-11-09 | 2012-04-03 | Siemens Aktiengesellschaft | Method of preparing a product quote for a customer |
JP2006155047A (en) * | 2004-11-26 | 2006-06-15 | Nec Electronics Corp | Verification system and verification method |
US8855981B2 (en) * | 2004-12-13 | 2014-10-07 | The Mathworks, Inc. | Tools for system-level design environments |
US8812269B1 (en) * | 2004-12-13 | 2014-08-19 | The Mathworks, Inc. | Dynamic range assessment in block diagram systems |
WO2006069491A1 (en) * | 2004-12-31 | 2006-07-06 | Intel Corporation | Remote logging mechanism |
WO2006094427A1 (en) * | 2005-03-07 | 2006-09-14 | Intel Corporation | Self-adaptive multicast file transfer protocol |
US20060224925A1 (en) * | 2005-04-05 | 2006-10-05 | International Business Machines Corporation | Method and system for analyzing an application |
US7458064B2 (en) * | 2005-04-11 | 2008-11-25 | Microsoft Corporation | Methods and apparatus for generating a work item in a bug tracking system |
US8719419B2 (en) * | 2005-04-21 | 2014-05-06 | Qualcomm Incorporated | Methods and apparatus for determining aspects of multimedia performance of a wireless device |
US8140614B2 (en) * | 2005-06-02 | 2012-03-20 | International Business Machines Corporation | Distributed computing environment with remote data collection management |
US7730246B2 (en) * | 2005-06-30 | 2010-06-01 | Intel Corporation | Opportunistic transmission of software state information within a link based computing system |
US7844854B2 (en) * | 2005-06-30 | 2010-11-30 | Intel Corporation | Opportunistic transmission of computing system state information within a link based computing system |
US8984636B2 (en) | 2005-07-29 | 2015-03-17 | Bit9, Inc. | Content extractor and analysis system |
US8272058B2 (en) | 2005-07-29 | 2012-09-18 | Bit 9, Inc. | Centralized timed analysis in a network security system |
US7895651B2 (en) | 2005-07-29 | 2011-02-22 | Bit 9, Inc. | Content tracking in a network security system |
US7614043B2 (en) * | 2005-08-26 | 2009-11-03 | Microsoft Corporation | Automated product defects analysis and reporting |
US8117255B2 (en) * | 2005-09-07 | 2012-02-14 | Sap Ag | Systems and methods for smart client remote data monitoring |
US7969922B2 (en) | 2006-01-31 | 2011-06-28 | Qualcomm Incorporated | Apparatus and methods for providing configurable task management of a wireless device |
US7546493B2 (en) * | 2006-04-28 | 2009-06-09 | Siemens Aktiengesellschaft | Method for responding to errors occurring during operation of a networked medical system |
US20080141221A1 (en) * | 2006-12-08 | 2008-06-12 | Microsoft Corporation | Using recorder technology to find defects in software applications |
US8504995B2 (en) * | 2007-05-09 | 2013-08-06 | Accenture Global Services Limited | Process flow analysis based on processing artifacts |
US20090063266A1 (en) * | 2007-09-04 | 2009-03-05 | Microsoft Corporation | Performing of marketing actions while preserving confidentiality |
US8543683B2 (en) * | 2007-09-26 | 2013-09-24 | Microsoft Corporation | Remote monitoring of local behavior of network applications |
US20090083363A1 (en) * | 2007-09-26 | 2009-03-26 | Microsoft Corporation | Remote monitoring of local behavior of network applications |
US8108513B2 (en) * | 2007-09-26 | 2012-01-31 | Microsoft Corporation | Remote monitoring of local behavior of network applications |
US7509539B1 (en) * | 2008-05-28 | 2009-03-24 | International Business Machines Corporation | Method for determining correlation of synchronized event logs corresponding to abnormal program termination |
US8261242B2 (en) * | 2008-06-09 | 2012-09-04 | International Business Machines Corporation | Assisting debug memory tracing using an instruction array that tracks the addresses of instructions modifying user specified objects |
US8566798B2 (en) * | 2008-10-15 | 2013-10-22 | International Business Machines Corporation | Capturing context information in a currently occurring event |
US8037191B2 (en) | 2008-11-10 | 2011-10-11 | Cisco Technology, Inc. | Low-level remote sharing of local devices in a remote access session across a computer network |
US8645922B2 (en) * | 2008-11-25 | 2014-02-04 | Sap Ag | System and method of implementing a concurrency profiler |
US8352795B2 (en) * | 2009-02-11 | 2013-01-08 | Honeywell International Inc. | High integrity processor monitor |
US20100218171A1 (en) * | 2009-02-26 | 2010-08-26 | Computer Measurement Laboratory, Inc. | Computer bus monitoring for the adaptive control of executing software processes |
US8972787B2 (en) * | 2009-03-31 | 2015-03-03 | Microsoft Technology Licensing, Llc | Dynamic collection of instrumentation data |
US9189620B2 (en) * | 2009-06-30 | 2015-11-17 | Intel Corporation | Protecting a software component using a transition point wrapper |
US8589859B2 (en) | 2009-09-01 | 2013-11-19 | Accenture Global Services Limited | Collection and processing of code development information |
KR101789266B1 (en) | 2010-05-19 | 2017-11-20 | 구글 엘엘씨 | Bug clearing house |
US9191298B1 (en) * | 2011-08-01 | 2015-11-17 | Google Inc. | Distributed forensic investigation |
CN103237082B (en) * | 2013-05-06 | 2016-07-27 | 百度在线网络技术(北京)有限公司 | Cloud method of testing, system and cloud server |
US9438491B1 (en) * | 2014-03-11 | 2016-09-06 | Apteligent, Inc. | Service monitor for monitoring a network connection to track the performance of an application running on different mobile devices |
CN108073499B (en) * | 2016-11-10 | 2020-09-29 | 腾讯科技(深圳)有限公司 | Application program testing method and device |
US11360872B2 (en) | 2018-10-18 | 2022-06-14 | Hewlett-Packard Development Company, L.P. | Creating statistical analyses of data for transmission to servers |
US11449370B2 (en) | 2018-12-11 | 2022-09-20 | DotWalk, Inc. | System and method for determining a process flow of a software application and for automatically generating application testing code |
US11025508B1 (en) | 2020-04-08 | 2021-06-01 | Servicenow, Inc. | Automatic determination of code customizations |
US11296922B2 (en) | 2020-04-10 | 2022-04-05 | Servicenow, Inc. | Context-aware automated root cause analysis in managed networks |
US10999152B1 (en) | 2020-04-20 | 2021-05-04 | Servicenow, Inc. | Discovery pattern visualizer |
US11301435B2 (en) | 2020-04-22 | 2022-04-12 | Servicenow, Inc. | Self-healing infrastructure for a dual-database system |
US11392768B2 (en) | 2020-05-07 | 2022-07-19 | Servicenow, Inc. | Hybrid language detection model |
US11263195B2 (en) | 2020-05-11 | 2022-03-01 | Servicenow, Inc. | Text-based search of tree-structured tables |
US11470107B2 (en) | 2020-06-10 | 2022-10-11 | Servicenow, Inc. | Matching configuration items with machine learning |
US11277359B2 (en) | 2020-06-11 | 2022-03-15 | Servicenow, Inc. | Integration of a messaging platform with a remote network management application |
US11451573B2 (en) | 2020-06-16 | 2022-09-20 | Servicenow, Inc. | Merging duplicate items identified by a vulnerability analysis |
US11379089B2 (en) | 2020-07-02 | 2022-07-05 | Servicenow, Inc. | Adaptable user interface layout for applications |
US11277321B2 (en) | 2020-07-06 | 2022-03-15 | Servicenow, Inc. | Escalation tracking and analytics system |
US11301503B2 (en) | 2020-07-10 | 2022-04-12 | Servicenow, Inc. | Autonomous content orchestration |
US11449535B2 (en) | 2020-07-13 | 2022-09-20 | Servicenow, Inc. | Generating conversational interfaces based on metadata |
US11632300B2 (en) | 2020-07-16 | 2023-04-18 | Servicenow, Inc. | Synchronization of a shared service configuration across computational instances |
US11748115B2 (en) | 2020-07-21 | 2023-09-05 | Servicenow, Inc. | Application and related object schematic viewer for software application change tracking and management |
US11343079B2 (en) | 2020-07-21 | 2022-05-24 | Servicenow, Inc. | Secure application deployment |
US11272007B2 (en) | 2020-07-21 | 2022-03-08 | Servicenow, Inc. | Unified agent framework including push-based discovery and real-time diagnostics features |
US11582106B2 (en) | 2020-07-22 | 2023-02-14 | Servicenow, Inc. | Automatic discovery of cloud-based infrastructure and resources |
US11095506B1 (en) | 2020-07-22 | 2021-08-17 | Servicenow, Inc. | Discovery of resources associated with cloud operating system |
US10958523B1 (en) | 2020-07-28 | 2021-03-23 | Bank Of America Corporation | Consistent deployment of monitoring configurations on multiple computing systems |
US11188437B1 (en) | 2020-07-30 | 2021-11-30 | Bank Of America Corporation | Remote deployment of monitoring agents on computing systems |
US11275580B2 (en) | 2020-08-12 | 2022-03-15 | Servicenow, Inc. | Representing source code as implicit configuration items |
US11372920B2 (en) | 2020-08-31 | 2022-06-28 | Servicenow, Inc. | Generating relational charts with accessibility for visually-impaired users |
US11245591B1 (en) | 2020-09-17 | 2022-02-08 | Servicenow, Inc. | Implementation of a mock server for discovery applications |
US11625141B2 (en) | 2020-09-22 | 2023-04-11 | Servicenow, Inc. | User interface generation with machine learning |
US11150784B1 (en) | 2020-09-22 | 2021-10-19 | Servicenow, Inc. | User interface elements for controlling menu displays |
US11632303B2 (en) | 2020-10-07 | 2023-04-18 | Servicenow, Inc | Enhanced service mapping based on natural language processing |
US11734025B2 (en) | 2020-10-14 | 2023-08-22 | Servicenow, Inc. | Configurable action generation for a remote network management platform |
US11342081B2 (en) | 2020-10-21 | 2022-05-24 | Servicenow, Inc. | Privacy-enhanced contact tracing using mobile applications and portable devices |
US11258847B1 (en) | 2020-11-02 | 2022-02-22 | Servicenow, Inc. | Assignments of incoming requests to servers in computing clusters and other environments |
US11363115B2 (en) | 2020-11-05 | 2022-06-14 | Servicenow, Inc. | Integrated operational communications between computational instances of a remote network management platform |
US11868593B2 (en) | 2020-11-05 | 2024-01-09 | Servicenow, Inc. | Software architecture and user interface for process visualization |
US11281442B1 (en) | 2020-11-18 | 2022-03-22 | Servicenow, Inc. | Discovery and distribution of software applications between multiple operational environments |
US11693831B2 (en) | 2020-11-23 | 2023-07-04 | Servicenow, Inc. | Security for data at rest in a remote network management platform |
US11269618B1 (en) | 2020-12-10 | 2022-03-08 | Servicenow, Inc. | Client device support for incremental offline updates |
US11216271B1 (en) | 2020-12-10 | 2022-01-04 | Servicenow, Inc. | Incremental update for offline data access |
US11630717B2 (en) | 2021-01-06 | 2023-04-18 | Servicenow, Inc. | Machine-learning based similarity engine |
US11301365B1 (en) | 2021-01-13 | 2022-04-12 | Servicenow, Inc. | Software test coverage through real-time tracing of user activity |
US11418586B2 (en) | 2021-01-19 | 2022-08-16 | Servicenow, Inc. | Load balancing of discovery agents across proxy servers |
US11301271B1 (en) | 2021-01-21 | 2022-04-12 | Servicenow, Inc. | Configurable replacements for empty states in user interfaces |
US11921878B2 (en) | 2021-01-21 | 2024-03-05 | Servicenow, Inc. | Database security through obfuscation |
US11513885B2 (en) | 2021-02-16 | 2022-11-29 | Servicenow, Inc. | Autonomous error correction in a multi-application platform |
US11722558B2 (en) * | 2021-02-23 | 2023-08-08 | Seagate Technology Llc | Server-side resource monitoring in a distributed data storage environment |
US11277369B1 (en) | 2021-03-02 | 2022-03-15 | Servicenow, Inc. | Message queue architecture and interface for a multi-application platform |
US11831729B2 (en) | 2021-03-19 | 2023-11-28 | Servicenow, Inc. | Determining application security and correctness using machine learning based clustering and similarity |
US11640369B2 (en) | 2021-05-05 | 2023-05-02 | Servicenow, Inc. | Cross-platform communication for facilitation of data sharing |
US11635752B2 (en) | 2021-05-07 | 2023-04-25 | Servicenow, Inc. | Detection and correction of robotic process automation failures |
US11635953B2 (en) | 2021-05-07 | 2023-04-25 | Servicenow, Inc. | Proactive notifications for robotic process automation |
US11277475B1 (en) | 2021-06-01 | 2022-03-15 | Servicenow, Inc. | Automatic discovery of storage cluster |
US11762668B2 (en) | 2021-07-06 | 2023-09-19 | Servicenow, Inc. | Centralized configuration data management and control |
US11418571B1 (en) | 2021-07-29 | 2022-08-16 | Servicenow, Inc. | Server-side workflow improvement based on client-side data mining |
US11516307B1 (en) | 2021-08-09 | 2022-11-29 | Servicenow, Inc. | Support for multi-type users in a single-type computing system |
US11734381B2 (en) | 2021-12-07 | 2023-08-22 | Servicenow, Inc. | Efficient downloading of related documents |
US11829233B2 (en) | 2022-01-14 | 2023-11-28 | Servicenow, Inc. | Failure prediction in a computing system based on machine learning applied to alert data |
US11582317B1 (en) | 2022-02-07 | 2023-02-14 | Servicenow, Inc. | Payload recording and comparison techniques for discovery |
US11734150B1 (en) | 2022-06-10 | 2023-08-22 | Servicenow, Inc. | Activity tracing through event correlation across multiple software applications |
Citations (38)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US4589068A (en) * | 1983-10-03 | 1986-05-13 | Digital Equipment Corporation | Segmented debugger |
US4802165A (en) * | 1986-10-08 | 1989-01-31 | Enteleki, Inc. | Method and apparatus of debugging computer programs |
US4964065A (en) * | 1987-03-12 | 1990-10-16 | Decibel Products, Inc. | Computer-controlled electronic system monitor |
US5121501A (en) * | 1989-12-27 | 1992-06-09 | International Business Machines Corporation | First processor inserting hooks into software and sending unique identifications to output bus and second processor associating data frames and time with these unique identifications |
US5142679A (en) * | 1981-03-25 | 1992-08-25 | Hitachi, Ltd. | Method and apparatus for collecting execution status data of structured program |
US5175856A (en) * | 1990-06-11 | 1992-12-29 | Supercomputer Systems Limited Partnership | Computer with integrated hierarchical representation (ihr) of program wherein ihr file is available for debugging and optimizing during target execution |
US5193180A (en) * | 1991-06-21 | 1993-03-09 | Pure Software Inc. | System for modifying relocatable object code files to monitor accesses to dynamically allocated memory |
US5237691A (en) * | 1990-08-01 | 1993-08-17 | At&T Bell Laboratories | Method and apparatus for automatically generating parallel programs from user-specified block diagrams |
US5247683A (en) * | 1990-06-28 | 1993-09-21 | International Business Machines Corporation | System and method for installing software and updating configuration files |
US5287453A (en) * | 1990-09-18 | 1994-02-15 | Bull Hn Information Systems, Inc. | Fast remote file access facility for distributing file access requests in a closely coupled computer system |
US5313616A (en) * | 1990-09-18 | 1994-05-17 | 88Open Consortium, Ltd. | Method for analyzing calls of application program by inserting monitoring routines into the executable version and redirecting calls to the monitoring routines |
US5325530A (en) * | 1993-01-29 | 1994-06-28 | International Business Machines Corporation | Controller for sequential programming tools executed in a parallel computing environment |
US5333304A (en) * | 1991-05-03 | 1994-07-26 | International Business Machines Corporation | Method and apparatus for software application evaluation utilizing compiler applications |
US5355484A (en) * | 1991-08-12 | 1994-10-11 | International Business Machines Corporation | Dynamically established event monitors in event management services of a computer system |
US5367670A (en) * | 1991-06-24 | 1994-11-22 | Compaq Computer Corporation | Computer system manager for monitoring events and operating parameters and generating alerts |
US5371746A (en) * | 1991-05-31 | 1994-12-06 | Fuji Xerox Co., Ltd. | Program debugging system for a distributed data processing system |
US5371883A (en) * | 1993-03-26 | 1994-12-06 | International Business Machines Corporation | Method of testing programs in a distributed environment |
US5375206A (en) * | 1991-03-11 | 1994-12-20 | Hewlett-Packard Company | Method for licensing software |
US5388211A (en) * | 1989-04-28 | 1995-02-07 | Softel, Inc. | Method and apparatus for remotely controlling and monitoring the use of computer software |
US5388268A (en) * | 1992-09-18 | 1995-02-07 | Hewlett-Packard Company | Methods of indicating states of software processes cooperating on a single task |
US5422791A (en) * | 1991-12-09 | 1995-06-06 | Robert Bosch Gmbh | Terminal strip for electric switching device |
US5506955A (en) * | 1992-10-23 | 1996-04-09 | International Business Machines Corporation | System and method for monitoring and optimizing performance in a data processing system |
US5511185A (en) * | 1990-11-27 | 1996-04-23 | Mercury Interactive Corporation | System for automatic testing of computer software having output synchronization and capable of responding to asynchronous events |
US5539659A (en) * | 1993-02-22 | 1996-07-23 | Hewlett-Packard Company | Network analysis method |
US5539907A (en) * | 1994-03-01 | 1996-07-23 | Digital Equipment Corporation | System for monitoring computer system performance |
US5541911A (en) * | 1994-10-12 | 1996-07-30 | 3Com Corporation | Remote smart filtering communication management system |
US5557780A (en) * | 1992-04-30 | 1996-09-17 | Micron Technology, Inc. | Electronic data interchange system for managing non-standard data |
US5561763A (en) * | 1994-02-10 | 1996-10-01 | Fujitsu Limited | Method and apparatus for testing an application in a client/server database system using pseudo-database server and debugger processes |
US5632022A (en) * | 1991-11-13 | 1997-05-20 | The United States Of America As Represented By The Administrator Of The National Aeronautics And Space Administration | Encyclopedia of software components |
US5644709A (en) * | 1994-04-21 | 1997-07-01 | Wisconsin Alumni Research Foundation | Method for detecting computer memory access errors |
US5647056A (en) * | 1992-11-18 | 1997-07-08 | Canon Information Systems, Inc. | Method and apparatus for managing access to a networked peripheral |
US5675798A (en) * | 1993-07-27 | 1997-10-07 | International Business Machines Corporation | System and method for selectively and contemporaneously monitoring processes in a multiprocessing server |
US5675802A (en) * | 1995-03-31 | 1997-10-07 | Pure Atria Corporation | Version control system for geographically distributed software development |
US5701724A (en) * | 1989-06-05 | 1997-12-30 | Schreiber Fodds, Inc. | Method and apparatus for forming and hermetically sealing slices of food items |
US5710724A (en) * | 1995-04-20 | 1998-01-20 | Digital Equipment Corp. | Dynamic computer performance monitor |
US5819093A (en) * | 1995-03-03 | 1998-10-06 | Sun Microsystems, Inc. | System and method for a distributed debugger for debugging distributed application programs |
US5918004A (en) * | 1995-06-02 | 1999-06-29 | Rational Software Corporation | Remote monitoring of computer programs |
US6009514A (en) * | 1997-03-10 | 1999-12-28 | Digital Equipment Corporation | Computer method and apparatus for analyzing program instructions executing in a computer system |
Family Cites Families (6)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US4821178A (en) * | 1986-08-15 | 1989-04-11 | International Business Machines Corporation | Internal performance monitoring by event sampling |
US5701427A (en) * | 1989-09-19 | 1997-12-23 | Digital Equipment Corp. | Information transfer arrangement for distributed computer system |
WO1993020511A1 (en) * | 1992-03-31 | 1993-10-14 | Aggregate Computing, Inc. | An integrated remote execution system for a heterogenous computer network environment |
FR2711026B1 (en) * | 1993-10-04 | 1995-12-08 | France Telecom | System for managing the consumption of data consultations on a telecommunications network. |
US5602729A (en) * | 1994-03-15 | 1997-02-11 | Mercury Computer Systems, Inc. | Method and apparatus for monitoring and controlling multiprocessor digital data processing systems |
WO1996003690A1 (en) * | 1994-07-22 | 1996-02-08 | Debenedictis Erik P | Method and apparatus for controlling connected computers without programming |
-
1996
- 1996-05-31 EP EP96916895A patent/EP0830611A4/en not_active Ceased
- 1996-05-31 CA CA002224689A patent/CA2224689C/en not_active Expired - Fee Related
- 1996-05-31 WO PCT/US1996/008240 patent/WO1996038733A1/en active Application Filing
- 1996-06-03 US US08/657,106 patent/US5918004A/en not_active Expired - Lifetime
-
1999
- 1999-06-28 US US09/340,862 patent/US6263457B1/en not_active Expired - Lifetime
-
2001
- 2001-07-16 US US09/907,510 patent/US6634001B2/en not_active Expired - Lifetime
-
2003
- 2003-08-15 US US10/642,387 patent/US7299455B2/en not_active Expired - Fee Related
-
2007
- 2007-11-20 US US11/986,310 patent/US20080147853A1/en not_active Abandoned
Patent Citations (44)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US5142679A (en) * | 1981-03-25 | 1992-08-25 | Hitachi, Ltd. | Method and apparatus for collecting execution status data of structured program |
US4589068A (en) * | 1983-10-03 | 1986-05-13 | Digital Equipment Corporation | Segmented debugger |
US4802165A (en) * | 1986-10-08 | 1989-01-31 | Enteleki, Inc. | Method and apparatus of debugging computer programs |
US4964065A (en) * | 1987-03-12 | 1990-10-16 | Decibel Products, Inc. | Computer-controlled electronic system monitor |
US5388211A (en) * | 1989-04-28 | 1995-02-07 | Softel, Inc. | Method and apparatus for remotely controlling and monitoring the use of computer software |
US5701724A (en) * | 1989-06-05 | 1997-12-30 | Schreiber Fodds, Inc. | Method and apparatus for forming and hermetically sealing slices of food items |
US5121501A (en) * | 1989-12-27 | 1992-06-09 | International Business Machines Corporation | First processor inserting hooks into software and sending unique identifications to output bus and second processor associating data frames and time with these unique identifications |
US5175856A (en) * | 1990-06-11 | 1992-12-29 | Supercomputer Systems Limited Partnership | Computer with integrated hierarchical representation (ihr) of program wherein ihr file is available for debugging and optimizing during target execution |
US5247683A (en) * | 1990-06-28 | 1993-09-21 | International Business Machines Corporation | System and method for installing software and updating configuration files |
US5237691A (en) * | 1990-08-01 | 1993-08-17 | At&T Bell Laboratories | Method and apparatus for automatically generating parallel programs from user-specified block diagrams |
US5313616A (en) * | 1990-09-18 | 1994-05-17 | 88Open Consortium, Ltd. | Method for analyzing calls of application program by inserting monitoring routines into the executable version and redirecting calls to the monitoring routines |
US5287453A (en) * | 1990-09-18 | 1994-02-15 | Bull Hn Information Systems, Inc. | Fast remote file access facility for distributing file access requests in a closely coupled computer system |
US5511185A (en) * | 1990-11-27 | 1996-04-23 | Mercury Interactive Corporation | System for automatic testing of computer software having output synchronization and capable of responding to asynchronous events |
US5375206A (en) * | 1991-03-11 | 1994-12-20 | Hewlett-Packard Company | Method for licensing software |
US5333304A (en) * | 1991-05-03 | 1994-07-26 | International Business Machines Corporation | Method and apparatus for software application evaluation utilizing compiler applications |
US5371746A (en) * | 1991-05-31 | 1994-12-06 | Fuji Xerox Co., Ltd. | Program debugging system for a distributed data processing system |
US5335344A (en) * | 1991-06-21 | 1994-08-02 | Pure Software Inc. | Method for inserting new machine instructions into preexisting machine code to monitor preexisting machine access to memory |
US6618824B1 (en) * | 1991-06-21 | 2003-09-09 | Rational Software Corporation | Method and apparatus for modifying relocatable object code files and monitoring programs |
US5193180A (en) * | 1991-06-21 | 1993-03-09 | Pure Software Inc. | System for modifying relocatable object code files to monitor accesses to dynamically allocated memory |
US5835701A (en) * | 1991-06-21 | 1998-11-10 | Rational Software Corporation | Method and apparatus for modifying relocatable object code files and monitoring programs |
US6206584B1 (en) * | 1991-06-21 | 2001-03-27 | Rational Software Corporation | Method and apparatus for modifying relocatable object code files and monitoring programs |
US5535329A (en) * | 1991-06-21 | 1996-07-09 | Pure Software, Inc. | Method and apparatus for modifying relocatable object code files and monitoring programs |
US5367670A (en) * | 1991-06-24 | 1994-11-22 | Compaq Computer Corporation | Computer system manager for monitoring events and operating parameters and generating alerts |
US5355484A (en) * | 1991-08-12 | 1994-10-11 | International Business Machines Corporation | Dynamically established event monitors in event management services of a computer system |
US5632022A (en) * | 1991-11-13 | 1997-05-20 | The United States Of America As Represented By The Administrator Of The National Aeronautics And Space Administration | Encyclopedia of software components |
US5422791A (en) * | 1991-12-09 | 1995-06-06 | Robert Bosch Gmbh | Terminal strip for electric switching device |
US5557780A (en) * | 1992-04-30 | 1996-09-17 | Micron Technology, Inc. | Electronic data interchange system for managing non-standard data |
US5388268A (en) * | 1992-09-18 | 1995-02-07 | Hewlett-Packard Company | Methods of indicating states of software processes cooperating on a single task |
US5506955A (en) * | 1992-10-23 | 1996-04-09 | International Business Machines Corporation | System and method for monitoring and optimizing performance in a data processing system |
US5647056A (en) * | 1992-11-18 | 1997-07-08 | Canon Information Systems, Inc. | Method and apparatus for managing access to a networked peripheral |
US5325530A (en) * | 1993-01-29 | 1994-06-28 | International Business Machines Corporation | Controller for sequential programming tools executed in a parallel computing environment |
US5539659A (en) * | 1993-02-22 | 1996-07-23 | Hewlett-Packard Company | Network analysis method |
US5371883A (en) * | 1993-03-26 | 1994-12-06 | International Business Machines Corporation | Method of testing programs in a distributed environment |
US5675798A (en) * | 1993-07-27 | 1997-10-07 | International Business Machines Corporation | System and method for selectively and contemporaneously monitoring processes in a multiprocessing server |
US5561763A (en) * | 1994-02-10 | 1996-10-01 | Fujitsu Limited | Method and apparatus for testing an application in a client/server database system using pseudo-database server and debugger processes |
US5539907A (en) * | 1994-03-01 | 1996-07-23 | Digital Equipment Corporation | System for monitoring computer system performance |
US5644709A (en) * | 1994-04-21 | 1997-07-01 | Wisconsin Alumni Research Foundation | Method for detecting computer memory access errors |
US5541911A (en) * | 1994-10-12 | 1996-07-30 | 3Com Corporation | Remote smart filtering communication management system |
US5819093A (en) * | 1995-03-03 | 1998-10-06 | Sun Microsystems, Inc. | System and method for a distributed debugger for debugging distributed application programs |
US5675802A (en) * | 1995-03-31 | 1997-10-07 | Pure Atria Corporation | Version control system for geographically distributed software development |
US5710724A (en) * | 1995-04-20 | 1998-01-20 | Digital Equipment Corp. | Dynamic computer performance monitor |
US5918004A (en) * | 1995-06-02 | 1999-06-29 | Rational Software Corporation | Remote monitoring of computer programs |
US6263457B1 (en) * | 1995-06-02 | 2001-07-17 | Rational Software Corporation | Remote monitoring of computer programs |
US6009514A (en) * | 1997-03-10 | 1999-12-28 | Digital Equipment Corporation | Computer method and apparatus for analyzing program instructions executing in a computer system |
Cited By (15)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US7984334B2 (en) | 2005-08-12 | 2011-07-19 | International Business Machines Corporation | Call-stack pattern matching for problem resolution within software |
US20100064179A1 (en) * | 2005-08-12 | 2010-03-11 | International Business Machines Corporation | Call-stack pattern matching for problem resolution within software |
US20070038896A1 (en) * | 2005-08-12 | 2007-02-15 | International Business Machines Corporation | Call-stack pattern matching for problem resolution within software |
US9064046B1 (en) * | 2006-01-04 | 2015-06-23 | Emc Corporation | Using correlated stack traces to determine faults in client/server software |
US20090328026A1 (en) * | 2007-03-20 | 2009-12-31 | Fujitsu Limited | Update system, program execution device, and computer program |
US20100128866A1 (en) * | 2008-11-26 | 2010-05-27 | Microsoft Corporation | Modification of system call behavior |
CN102053906A (en) * | 2009-10-30 | 2011-05-11 | 国际商业机器公司 | System and method for collecting program runtime information |
US20120167054A1 (en) * | 2009-10-30 | 2012-06-28 | International Business Machines Corporation | Collecting Program Runtime Information |
US20110107307A1 (en) * | 2009-10-30 | 2011-05-05 | International Business Machines Corporation | Collecting Program Runtime Information |
US20130185600A1 (en) * | 2012-01-12 | 2013-07-18 | International Business Machines Corporation | Thread based dynamic data collection |
US20130297977A1 (en) * | 2012-01-12 | 2013-11-07 | International Business Machines Corporation | Thread based dynamic data collection |
US9916192B2 (en) * | 2012-01-12 | 2018-03-13 | International Business Machines Corporation | Thread based dynamic data collection |
US10740166B2 (en) * | 2012-01-12 | 2020-08-11 | International Business Machines Corporation | Thread based dynamic data collection |
CN104735162A (en) * | 2015-04-10 | 2015-06-24 | 上海自仪泰雷兹交通自动化系统有限公司 | Remote log collection method used for security encryption devices of rail transit signal system |
US11177972B2 (en) * | 2016-07-29 | 2021-11-16 | International Business Machines Corporation | Event notification |
Also Published As
Publication number | Publication date |
---|---|
WO1996038733A1 (en) | 1996-12-05 |
EP0830611A4 (en) | 2007-05-09 |
US6634001B2 (en) | 2003-10-14 |
CA2224689A1 (en) | 1996-12-05 |
US20040153997A1 (en) | 2004-08-05 |
EP0830611A1 (en) | 1998-03-25 |
US20020049934A1 (en) | 2002-04-25 |
US7299455B2 (en) | 2007-11-20 |
US6263457B1 (en) | 2001-07-17 |
CA2224689C (en) | 2002-10-29 |
US5918004A (en) | 1999-06-29 |
Similar Documents
Publication | Publication Date | Title |
---|---|---|
US7299455B2 (en) | Remote monitoring of computer programs | |
US8589889B2 (en) | Apparatus and method of detecting errors in embedded software | |
US6922827B2 (en) | Iterative software development environment with prioritized build rules | |
US7127707B1 (en) | Intellisense in project upgrade | |
US7721265B1 (en) | Source code debugging method and apparatus for use in script testing environment | |
US8166458B2 (en) | Method and system for automated distributed software testing | |
US7917894B2 (en) | Constraining source code and objects for analysis tools | |
KR100655124B1 (en) | Software installation and testing system for a built-to-order computer system | |
US6077312A (en) | Apparatus, program product and method of debugging utilizing a context sensitive breakpoint | |
US6978401B2 (en) | Software application test coverage analyzer | |
US6161216A (en) | Source code debugging tool | |
US20050289538A1 (en) | Deploying an application software on a virtual deployment target | |
US7458064B2 (en) | Methods and apparatus for generating a work item in a bug tracking system | |
US7644394B2 (en) | Object-oriented creation breakpoints | |
US20130232245A1 (en) | Automation for virtualized it environments | |
EP0965921A2 (en) | Distributed indirect software instrumentation | |
US20070294593A1 (en) | Customizable system for the automatic gathering of software service information | |
US8533683B2 (en) | Stack walking enhancements using sensorpoints | |
US20080127061A1 (en) | Method and system for editing code | |
US20040168157A1 (en) | System and method for creating a process invocation tree | |
US7143394B1 (en) | Analyzing software behavior | |
US20050283763A1 (en) | Exception test support technique | |
Khan et al. | PASD: A Performance Analysis Approach Through the Statistical Debugging of Kernel Events | |
Lovas et al. | Debugging of metacomputing applications | |
Latkowski | DIXER User Manual |
Legal Events
Date | Code | Title | Description |
---|---|---|---|
STCB | Information on status: application discontinuation |
Free format text: ABANDONED -- FAILURE TO RESPOND TO AN OFFICE ACTION |