INJECTION OF UPDATED CLASSES FOR A JAVA AGENT

• US 20140059527A1
• Filed: 08/24/2012
• Published: 02/27/2014
• Est. Priority Date: 08/24/2012
• 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: Gagliardi, Marco
• Granted Patent: US 9,798,557 B2
• Time in Patent Office: Days
• US Class Current: 717/166
• CPC Class Codes: G06F 8/656 while running
• CPC Class Codes: G06F 9/44521 Dynamic linking or loading; Link editing at or after load time, e.g. Java class loading

Abstract

Technology is disclosed for updating an Agent. One embodiment comprises running the Agent for the Application while the Application is also running. The Agent is associated with an identified source of code for the Agent. The code for the Agent is updated, and the updated Agent is run with the Application.

Claims

1. A method of updating an Agent for an Application, comprising:

running the Agent for the Application while the Application is running, the Agent is associated with an identified source of code for the Agent;

locking the identified source of code for the Agent;

updating the code for the Agent while the identified source of code for the Agent is locked; and

running the updated Agent with the Application.

2. The method of claim 1, wherein:

the Agent is run in a Java Virtual Machine and uses classes loaded by the Bootstrap Classloader; and

the updating the Agent comprises dynamically instrumenting code for the Agent.

3. The method of claim 1, wherein:

the Agent is implemented using a -javaagent option of a Java Instrumentation API.

4. The method of claim 1, wherein:

the Agent is defined by first code in an Agent.jar file;

the locking the identified source of code for the Agent comprises locking the Agent.jar file; and

the updating the Agent comprises providing replacement code for the first code in the Agent.jar file while the Agent.jar file is locked.

5. The method of claim 1, wherein:

the updating the Agent is performed while the Application is running.

6. The method of claim 5, wherein:

the Agent and the Application are running in a Java Virtual Machine; and

the updating the Agent is performed while the Java Virtual Machine is running.

7. The method of claim 1, wherein:

the updating the Agent comprises dynamically instrumenting current code for the Agent to insert new code into one or more classes for the Agent, the new code is from a source not in a class path for the Agent.

8. The method of claim 1, further comprising:

providing a path to a first storage unit that stores code for the Agent and an indication of a particular Transformer;

registering the particular Transformer, the particular Transformer performs dynamic byte code instrumentation;

loading the code for the Agent into a Java Virtual machine from the storage unit the locking the identified source of code for the Agent comprises locking the first storage unit;

providing an instruction to the particular Transformer to update the Agent, the updating the Agent is performed by the particular Transformer.

9. The method of claim 8, wherein the updating the Agent comprises:

(a) the Java Virtual Machine requesting that the Bootstrap Classloader load the code for the Agent;

(b) the Bootstrap Classloader providing the code for the Agent to the particular Transformer;

(c) the particular Transformer accessing updated code from a second storage unit different than the first storage unit, the first storage unit is in a class path for the Agent and the second storage unit is not in the class path for the Agent;

(d) the particular Transformer providing the updated code to the bootstrap Classloader as an instrumented version of the code for the Agent; and

(e) the Bootstrap Classloader providing the updated code to the Java Virtual Machine as the byte code for Agent.

10. The method of claim 9, wherein:

steps (a)-(e) are performed separately for all classes of the Agent.

11. The method of claim 9, wherein the updating the Agent further comprises:

dynamically instrumenting already-instrumented classes of the Application to reference the updated code, while the Application is running.

12. The method of claim 9, wherein the updating the Agent comprises:

the particular Transformer checking updated code for the Agent to determine whether there is an updated Transformer; and

if there is an updated Transformer, then;

loading the updated Transformer,

registering the updated Transformer, and

unregistering the particular Transformer.

13. A method of updating a Java Agent for a Java Application, comprising:

running the Java Application in a Java Virtual Machine;

running the Agent in the Java Virtual Machine while the Application is running;

updating the Agent without re-starting the Application and the Java Virtual Machine; and

running the updated Agent with the Application.

14. The method of claim 13, wherein:

the Agent is implemented using a -javaagent option of a Java Instrumentation API.

15. The method of claim 13, further comprising:

locking a source of class files defining the Agent, the updating the Agent is performed while the source of the class files is locked.

16. The method of claim 13, wherein a source of class files defining the Agent comprises an indication of a particular Transformer, the method further comprising:

registering the particular Transformer, the particular Transformer performs dynamic byte code instrumentation;

loading code for the Agent into the Java Virtual machine from the source of the class files;

providing an instruction to the particular Transformer to update the Agent, the updating the Agent is performed by the particular Transformer.

17. The method of claim 16, wherein the updating the Agent comprises:

(a) the particular Transformer requesting that code for the Agent be loaded;

(b) the Java Virtual Machine requesting that a Classloader load the code for the Agent;

(c) the Classloader providing the code for the Agent to the particular Transformer;

(d) the particular Transformer accessing updated code from a update storage unit different than the source of the class files, the source of the class files is in a class path for the Agent and the update storage unit is not in the class path for the Agent;

(e) the particular Transformer providing the updated code to the Classloader as an instrumented version of the code for the Agent; and

(f) the Classloader providing the updated code to the Java Virtual Machine as the byte code for Agent.

18. The method of claim 17, wherein:

steps (b)-(f) are performed separately for all classes of the Agent.

19. The method of claim 17, wherein the updating the Agent further comprises:

dynamically instrumenting already-instrumented classes of the Application to reference the updated code, while the Application is running.

20. A computing apparatus, comprising:

a storage device that stores code including a first storage unit of code; and

one or more processors in communication with the storage device, the one or more processors run a Java Application and an Agent for the Java Application such that the Agent is implemented using a -javaagent option of a Java instrumentation API, the first storage unit of code stores code for a class of the Agent, while the Application is running the one or more processors lock the first storage unit of code, while the first storage unit of code is locked the Agent is updated by substituting new code for old code of the Agent.

21. The computing apparatus of claim 20, wherein:

the old code for the Agent was loaded by a Bootstrap Classloader for a Java Virtual Machine running the Application; and

the Agent is updated by the one or more processors dynamically instrumenting byte code for the Agent while the Application and the Java Virtual Machine are running.

22. The computing apparatus of claim 20, wherein:

the first storage unit of code comprises a Transformer;

the one or more processors register the Transformer, the Transformer performs dynamic byte code instrumentation, the one or more processors implement the Transformer;

an instruction is provided to the Transformer to update the Agent, the updating the Agent is performed by the Transformer.

23. The computing apparatus of claim 22, wherein:

a Java Virtual Machine requests that a Classloader load the code for the Agent;

the Classloader provides the code for the Agent to the Transformer;

the Transformer accesses updated code from a second storage unit of code different than the first storage unit of code, the first storage unit of code is in a class path for the Agent and the second storage unit of code is not in the class path for the Agent;

the Transformer provides the updated code to the Classloader as an instrumented version of the code for the Agent; and

the Classloader provides the updated code to the Java Virtual Machine as the byte code for Agent.

24. The computing apparatus of claim 23, wherein:

the one or more processors dynamically instrument already-instrumented classes of the Application to reference the updated code, while the Application is running.

25. A computer program product, comprising:

a computer readable storage medium having computer readable program code embodied thereon, the computer readable program code comprising;

computer readable program code configured to implement an Agent to run for an Application;

computer readable program code configured to dynamically instrument the Application to run with the Agent; and

computer readable program code configured to update the computer readable program code configured to implement the Agent while the computer readable program code configured to implement the Agent is locked.

26. The computer program product of claim 25, wherein:

the Agent and Application run in a Java Virtual Machine; and

the computer readable program code configured to update causes classes for the Agent loaded by a Bootstrap Classloader to be dynamically instrumented.

27. The computer program product of claim 25, wherein:

the Agent is implemented using a -javaagent option of a Java Instrumentation API.

28. The computer program product of claim 25, wherein:

the computer readable program code configured to update will update the computer readable program code configured to implement the Agent while the Application and Java Virtual Machine are running.