Detecting, logging and tracking component dependencies in web service transactions

• US 8,327,377 B2
• Filed: 04/30/2009
• Issued: 12/04/2012
• 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: Krishnamurthy, Anand, Thain, Stewart, Rader, Todd, Goulet, Michael
• Primary Examiner(s): An, Meng
• Assistant Examiner(s): WU, BENJAMIN C
• Application Number:
  US12/433,593
• Publication Number:
  US 20100281488A1
• Time in Patent Office: 1,314 Days
• Field of Search: None
• 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:

monitoring execution of the application using an agent;

in response to the monitoring, obtaining;

(a) an identifier of a called component, the called component executes in one thread of a transaction and is called by a calling component which executes in another thread of the transaction, and (b) a sequence identifier which identifies an order in which the called component was called by the calling component among multiple components which are called by the calling component in the transaction;

determining, at the agent, if there is an existing data structure comprising the identifier of the called component in a store;

if there is the existing data structure in the store, adding the sequence identifier to the existing data structure;

if there is not the existing data structure in the store, providing a new data structure comprising the identifier of the called component and the sequence identifier in the store; and

communicating the existing or new data structure in the store from the agent to a manager computer 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:

populating a stack for boundary components of the transaction with the identifier of the called component, the boundary components are marked by tracers of the application and the agent obtains the identifier of the called component from the stack.

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

the existing or new dependency data structure in the store is communicated from the agent to the manager computer in a batch, when at least one of;

a predetermined number of the data structures in the store is reached, and a predetermined time period has passed.

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

the sequence identifier identifies a number, which is two or more, of prior components in a sequence of components, prior to the called component of the one thread.

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

monitoring execution of the application using an agent;

in response to the monitoring, obtaining an identifier of a called component, the called component executes in one thread of a transaction and is called by another component which executes in another thread of the transaction, and to access a flag which is communicated to the called component by the calling component in a request header;

if the flag is set one way, providing a new structure in a store, the new data structure comprises the identifier of the called component and a sequence identifier, the sequence identifier indicates a sequence in which the called component was called;

if the flag is set another way;

determining if there is an existing data structure comprising the identifier of the called component in the store; and

if there is the existing data structure in the store, adding an identifier of the transaction to the existing data structure without creating a new data structure in the store;

if the flag is set the another way, and if there is not the existing data structure in the store, providing the new data structure in the store; and

communicating the existing or new data structure in the store to a manager computer for use in providing a graphical user interface which depicts dependencies among components of the application.

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

populating a stack for boundary components of the transaction with the identifier of the called component, the boundary components are marked by tracers of the application; and

creating a data structure from the stack, the determining if there is the identifier of the called component in the store comprises comparing the created data structure to a data structure in the store.

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

the identifier of the called component is obtained by a first agent which is associated with the one thread; and

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

8. The computer-implemented method of claim 5, wherein:

the sequence identifier identifies;

a number, which is two or more, of prior components in the sequence, prior to the called component, and an order in which the called component is called by the calling component among multiple components which are called by the calling component.

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

receiving data structures at a manager computer, the data structures comprise identifiers of boundary components of the application which execute in different threads of a transaction, and an indication of caller-callee relationships among the boundary components, the boundary components are marked by tracers of the application, one of the data structures comprises an identifier of a called component which is called by a calling component, and a sequence identifier which identifies an order in which the called component is called by the calling component among multiple components which are called by the calling component in the transaction, and a number, which is two or more, of prior components in a sequence of components, prior to the called component, and another of the data structures comprises an identifier of another called component which is called by another calling component, and an identifier of the another calling component;

preparing graph data based on the data structures, the graph data is based on the identifiers of the boundary 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 boundary components;

accessing the graph data based on the user command; and

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

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

the data structures comprise transaction identifiers which are used for correlating different data structures received from different agents.

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

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

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

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