DETECTING NON-REDUNDANT COMPONENT DEPENDENCIES IN WEB SERVICE INVOCATIONS

• US 20100281488A1
• Filed: 04/30/2009
• Published: 11/04/2010
• Est. Priority Date: 04/30/2009
• Status: Active Grant

• Current Assignee: CA, Inc. (d/b/a CA Technologies) (Broadcom, Inc.)
• Original Assignee: CA, Inc. (d/b/a CA Technologies) (Broadcom, Inc.)
• Inventors: Thain, Stewart, Krishnamurthy, Anand, Rader, Todd, Goulet, Michael
• Granted Patent: US 8,327,377 B2
• Time in Patent Office: Days
• US Class Current: 718/106
• CPC Class Codes: G06F 11/3495 for systems
• CPC Class Codes: G06F 11/3612 by runtime analysis performance monitoring G06F11/3466
• CPC Class Codes: G06F 11/3664 Environments for testing or debugging software
• CPC Class Codes: G06F 2201/865 Monitoring of software

Abstract

Relationships between components in an application and the services they provide are identified, including redundant caller-callee sequences. Specific components of interest are instrumented to obtain data when they execute. Data structures are created which identify the components and their dependencies on one other. To avoid excessive overhead costs, redundant dependencies are identified. A dependency data structure can be provided for each unique dependency. When repeated instances of a dependency are detected, the associated dependency data structure can be augmented with correlation data of the repeated instances, such as transaction identifiers and sequence identifiers. Sequence identifiers identify an order in which a component is called. A flag can be used to force the creation of a new dependency data structure, and a calling component'"'"'s name can be used instead of a sequence identifier. Agents report the dependency data structures to a manager to provide graph data in a user interface.

Claims

1. A computer-implemented method for identifying dependencies among components in an application, comprising:

accessing first information identifying a first dependency comprising at least one component which executes in a first thread of a transaction, and which is called by at least one component which executes in another thread of the transaction;

determining if there is a matching dependency for the first dependency in a store of at least one dependency data structure;

if there is the matching dependency in the store, accessing second information which identifies the at least one component which executes in the another thread, and determining if the matching dependency is associated with the second information;

if the matching dependency is not associated with the second information, adding the second information to a dependency data structure of the matching dependency in the store; and

communicating dependency data structures in the store to the manager for use in providing a graphical user interface which depicts dependencies among components of the application.

2. The computer-implemented method of claim 1, further comprising:

if there is not the matching dependency in the store, accessing second information which identifies the at least one component which executes in the another thread, and storing a new dependency data structure in the store which includes the first and second information.

3. The computer-implemented method of claim 1, further comprising:

if the matching dependency is associated with the second information, discarding the first and second information without storing a new dependency data structure in the store which includes the first and second information.

4. The computer-implemented method of claim 1, further comprising:

populating a lightweight stack with the first information; and

creating a dependency data structure from the lightweight stack;

where the determining if there is the matching dependency in the store comprises comparing the created dependency data structure to the at least one dependency data structure in the store.

5. The computer-implemented method of claim 1, further comprising:

when the matching dependency is not associated with the second information, the second information is added to the dependency data structure of the matching dependency in the store so that the dependency data structure of the matching dependency identifies multiple components which called the matching dependency, the multiple components are in respective different threads.

6. The computer-implemented method of claim 1, wherein:

the second information is accessed from an inter-computing system call made from the at least one component which executes in the another thread to the at least one component which executes in the first thread.

7. A computer-implemented method for identifying dependencies among components in an application, comprising:

accessing first information identifying (a) a first dependency comprising at least one component which executes in a first thread of a transaction, and which is called by at least one component which executes in another thread of the transaction, and (b) a sequence identifier which indicates an order in which the at least one component of the first thread was called by the at least one component of the another thread;

determining if there is a matching dependency for the first dependency in a store of at least one dependency data structure;

if there is the matching dependency in the store, adding the sequence identifier to a dependency data structure of the matching dependency in the store;

if there is not the matching dependency in the store, providing a new dependency data structure in the store which includes the at least one component which executes in the first thread and the sequence identifier; and

communicating dependency data structures in the store to a manager for use in providing a graphical user interface which depicts dependencies among components of the application.

8. The computer-implemented method of claim 7, further comprising:

populating a lightweight stack with the at least one component which executes in the first thread; and

creating a dependency data structure from the lightweight stack;

where the determining if there is the matching dependency in the store comprises comparing the created dependency data structure to the at least one dependency data structure in the store.

9. The computer-implemented method of claim 7, wherein:

the dependency data structures in the store are communicated to the manager in batches, when a predetermined number of the dependency data structures in the store is reached.

10. The computer-implemented method of claim 7, wherein:

the dependency data structures in the store are communicated to the manager in batches, when a predetermined time period has passed.

11. The computer-implemented method of claim 7, wherein:

the sequence identifier identifies a number of prior components in a sequence of components which includes the at least one component of the first thread and the at least one component of the another thread.

12. A computer-implemented method for identifying dependencies among components in an application, comprising:

accessing first information identifying a first dependency comprising at least one component which executes in a first thread of a transaction, and which is called by at least one component which executes in another thread of the transaction;

accessing a flag;

if the flag is set one way, providing a new dependency data structure in a store which includes the at least one component which executes in the first thread, and the sequence identifier;

if the flag is set another way, determining if there is a matching dependency for the first dependency in the store, the store comprises at least one dependency data structure;

if the flag is set the another way, and if there is the matching dependency in the store, discarding the first information without storing a new dependency data structure in the store which includes the first information;

if the flag is set the another way, and if there is not the matching dependency in the store, providing a new dependency data structure in the store which includes the first information; and

communicating dependency data structures in the store to a manager for use in providing a graphical user interface which depicts dependencies among components of the application.

13. The computer-implemented method of claim 12, further comprising:

populating a lightweight stack with the at least one component which executes in the first thread; and

creating a dependency data structure from the lightweight stack;

where the determining if there is the matching dependency in the store comprises comparing the created dependency data structure to the at least one dependency data structure in the store.

14. The computer-implemented method of claim 12, wherein:

the accessing the first information is performed by a first agent which is associated with the first thread; and

a second agent which is associated with the another thread sets the flag.

15. A computer-implemented method for identifying dependencies among instrumented components in an application, comprising:

receiving dependency data structures at a manager, the dependency data structures include identifiers of components of the application which execute in different threads of a transaction, and an indication of caller-callee relationships among the components;

preparing graph data based on the dependency data structures, the graph data is based on the identifiers of the components and the indication of the caller-callee relationships;

receiving a user command via a graphical user interface to access the graph data for at least a portion of the components;

accessing the graph data based on the user command; and

providing a graphical user interface using the accessed portion of the graph data, the graphical user interface depicts caller-callee relationships among the at least a portion of the components, and names of services of the application which are represented by the at least a portion of the components.

16. The computer-implemented method of claim 15, wherein:

the dependency data structures include transaction identifiers which are used for correlating different dependency data structures.

17. The computer-implemented method of claim 15, wherein:

the dependency data structures include at least a first dependency data structure which includes an identifier of a first component which is called by another component, and an identifier of the another component.

18. The computer-implemented method of claim 17, wherein:

the dependency data structures include at least a first dependency data structure which includes an identifier of a first component which is called by another component, and a sequence identifier which identifies an order in which the first component is called by another component among multiple components which are called by the another component.

19. The computer-implemented method of claim 15, wherein:

the names of the services provided on the graphical user interface include URLs, and the graphical user interface identifies caller-callee relationships among the URLs.

20. The computer-implemented method of claim 19, wherein:

the names of the services provided on the graphical user interface include class names, and the graphical user interface identifies which class names are associated with which URLs.