Transparent node runtime and management layer

• US 10,055,199 B2
• Filed: 02/10/2016
• Issued: 08/21/2018
• Est. Priority Date: 02/10/2016
• Status: Active Grant

• Current Assignee: NodeSource, Inc. (Interactive Insights, Inc.)
• Original Assignee: NodeSource, Inc. (Interactive Insights, Inc.)
• Inventors: Baril, Bryce B., Shaw, Daniel D., Vagg, Roderick D., McCann, Joseph I., Renfroe, Gavon A., Lorenz, Thorsten, Norris, Trevor J., Insua, Elijah F., Ray, III, Fountain L.
• Primary Examiner(s): Brophy, Matthew J
• Application Number:
  US15/040,309
• Publication Number:
  US 20170228217A1
• Time in Patent Office: 923 Days
• Field of Search: None
• CPC Class Codes: G06F 11/30 Monitoring
• CPC Class Codes: G06F 11/3017 where the computing system is implementing multitasking multiprogramming arrangements G06F9/46; allocation of resources G06F9/50
• CPC Class Codes: G06F 11/302 where the computing system component is a software system
• CPC Class Codes: G06F 11/3409 for performance assessment
• CPC Class Codes: G06F 11/3452 Performance evaluation by statistical analysis
• CPC Class Codes: G06F 11/3466 Performance evaluation by tracing or monitoring
• CPC Class Codes: G06F 11/3476 Data logging G06F11/14, G06F11/2205 take precedence
• CPC Class Codes: G06F 2201/86 Event-based monitoring
• CPC Class Codes: G06F 2201/865 Monitoring of software
• CPC Class Codes: G06F 8/20 Software design
• CPC Class Codes: G06F 9/45529 Embedded in an application, e.g. JavaScript in a Web browser

Abstract

A server computer. The server computer comprises a processor, a non-transitory memory, a application comprising JavaScript instructions stored in the non-transitory memory, a runtime stored in the non-transitory memory, and a native agent module stored in the non-transitory memory. When executed by the processor, the runtime provides a JavaScript execution environment for executing the application and an instrumentation application programming interface (API). When executed by the processor outside of the runtime, the native agent module monitors memory buffers allocated to the application based on accessing the instrumentation API of the runtime, executes an event loop that sends an interrupt to the runtime, and provides reporting based on monitoring the memory buffers and the interrupt sent to the runtime to a management layer external to the server computer.

Claims

1. A server computer, comprising:

a processor;

a non-transitory memory, wherein the non-transitory memory stores a plurality of security rules;

an application comprising JavaScript instructions stored in the non-transitory memory;

a runtime stored in the non-transitory memory that, when executed by the processor,

provides a JavaScript execution environment for executing the application and an instrumentation application programming interface (API),

reads the security rules from the non-transitory memory, and

provides the JavaScript execution environment for executing the application according to constraints defined by the security rules; and

a native agent module stored in the non-transitory memory that, when executed by the processor outside of the runtime

monitors memory buffers allocated to the application based on accessing the instrumentation API of the runtime,

executes an event loop that sends an interrupt to the runtime, and

provides reporting based on monitoring the memory buffers and the interrupt sent to the runtime to a management layer external to the server computer.

2. The server of claim 1, wherein the runtime, when executed by the processor, creates memory buffer logs at the time of dynamic allocation of memory buffers to the application and wherein the native agent module monitors memory buffers by accessing the memory buffer logs via the instrumentation API of the runtime.

3. The server computer of claim 1, wherein the native agent module comprises call back methods and wherein the application comprises an agent application programming interface that the application, when executed by the processor, invokes to cause the native agent module, when executed by the processor, to execute one of the call back methods of the agent.

4. The server computer of claim 1, wherein the runtime, when executed by the processor, creates an include log that identifies the name of a module included by the application and wherein the native agent module, when executed by the processor, accesses the include log via the instrumentation API of the runtime and provides the include log in the reporting sent to the management layer external to the server computer.

5. The server computer of claim 1, wherein the native agent module, when executed by the processor, registers with the management layer external to the server computer and sends a heartbeat message periodically to the management layer external to the server computer.

6. The server computer of claim 1, wherein the runtime, when executed by the processor, creates event logs associated with events on a runtime event loop, wherein the event logs comprise an event handle, an identifier of a code file of the application that generated the event, and a line number in the code file that generated the event, and wherein the native agent module, when executed by the processor, accesses the event log via the instrumentation API of the runtime and provides the event log in the reporting sent to the management layer external to the server computer.

7. A method of executing a JavaScript application, comprising:

initiating a process on a first computer, where the process comprises

a runtime that provides a JavaScript execution environment for a JavaScript application and an instrumentation application programming interface (API) for a native agent module,

the JavaScript application that executes in the runtime, and

the native agent module that executes on the first computer outside of the runtime and accesses the instrumentation API of the runtime to monitor the runtime and the JavaScript application;

monitoring, by the native agent module, memory buffers allocated to the Javascript application at a time of a dynamic allocation of the memory buffers based on accessing the instrumentation API of the runtime, wherein the memory buffers are outside of a heap memory;

sending a request from a console application executing on a second computer to the native agent module, where the request identifies information monitored by the native agent module, wherein the information comprises information on the memory buffers;

receiving the information from the native agent module by the console application;

analyzing the received information by the console application to determine a current performance of the JavaScript application;

based on the analysis of performance of the JavaScript application, sending a command to the native agent module by the console application; and

providing a command input to the runtime by the native agent module based on the command sent by the console application,

whereby the runtime and the JavaScript application are monitored and controlled by the console application.

8. The method of claim 7, wherein analyzing the received information by the console application to determine the current performance of the JavaScript application further comprises comparing the current performance of the JavaScript application to a generalized performance of a set of peer JavaScript applications.

9. The method of claim 8, further comprising depicting the performance of the JavaScript application compared to the generalized performance of the set of peer JavaScript applications on a user interface display provided by the console application.

10. The method of claim 9, wherein the performance of the JavaScript application is presented on the user interface display as a point in a two-dimensional plane defined by a memory consumption axis and a CPU cycle consumption axis and the performance of the set of peer JavaScript applications are presented on the user interface display as points in the two-dimensional plane defined by the memory consumption axis and the CPU cycle consumption axis.

11. The method of claim 7, further comprising sending a request to interrupt the runtime from the console application to the native agent module, whereby the native agent module causes the runtime to breakout of one of an infinite loop or a lengthy processing step.

12. The method of claim 7, further comprising

analyzing the received information by the console application to identify modules included by the JavaScript application;

comparing the included modules to a list of black listed modules by the console application; and

generating by the console application a notification that one of the included modules is a black listed module.

13. The method of claim 12, further comprising:

comparing by the console application a checksum associated with the included modules included in the received information to an authoritative checksum associated with the included modules; and

generating by the console application a notification that the checksum associated with one of the included modules does not compare with the authoritative checksum associated with the included module.

14. A method of managing a plurality of JavaScript processes, comprising:

initiating a plurality of processes on a first computer system, where each process comprises

a runtime that provides a JavaScript execution environment for a JavaScript application and an instrumentation application programming interface (API) for a native agent module,

the JavaScript application that executes in the runtime, and

the native agent module that executes on the computer system outside of the runtime and accesses the instrumentation API of the runtime to monitor the runtime and the JavaScript application;

receiving registrations of the native agent modules of the plurality of processes by a hub application that executes on a second computer system;

in response to each native agent module registration, creating by the hub application an entry in a hub registry data store associated with the native agent module that identifies at least one identifier associated with the native agent module and a communication address of the native agent module;

receiving heartbeat messages from native agent modules by the hub application;

removing an entry from the hub registry data store in response to determining that a heartbeat message has not been received from a native agent module associated with an entry in the hub registry data store for at least a predefined length of time;

identifying a cluster comprising a plurality of JavaScript applications, wherein each JavaScript application of the plurality of JavaScript applications share a common property;

receiving a message from a management console by the hub application, where the message from the management console identifies the cluster;

looking up, by the hub application, a communication address of the each native agent module associated with each JavaScript application of the plurality of JavaScript applications in the cluster based on the cluster identified in the message from the management console; and

sending the message from the management console by the hub application to each identified native agent module at the looked-up communication address of each native agent module,

whereby the processes on the first computer system are managed and monitored by the management console.

15. The method of claim 14, wherein the communication address of the native agent modules identified in the entries in the hub registry data store comprises an internet protocol (IP) address.

16. The method of claim 15, wherein the communication address of the native agent modules further comprises a protocol port number.

17. The method of claim 14, wherein the plurality of processes on the first computer system implement a web server functionality.