CN114048099A

CN114048099A - Java application monitoring method and device, storage medium and electronic equipment

Info

Publication number: CN114048099A
Application number: CN202111348854.5A
Authority: CN
Inventors: 安卫杰; 李国莹; 常冬冬; 周明宏; 王艳华
Original assignee: China Construction Bank Corp
Current assignee: China Construction Bank Corp
Priority date: 2021-11-15
Filing date: 2021-11-15
Publication date: 2022-02-15

Abstract

The invention provides a Java application monitoring method and device, a storage medium and electronic equipment, wherein the method comprises the following steps: starting a preset monitoring acquisition script according to a preset time period, and acquiring a currently and effectively running Java process by applying the monitoring acquisition script; determining a monitoring object corresponding to the Java process, and setting a monitoring object name of the monitoring object; collecting each monitoring index corresponding to a monitored object, and outputting a monitoring data file corresponding to each monitoring index to a preset monitoring tool; applying a monitoring tool to perform data processing on the monitoring data file to obtain a processed monitoring data file; judging whether the monitoring data file is abnormal or not based on a preset monitoring rule; and if the monitored data file is abnormal, sending an alarm notice corresponding to the monitored object. By applying the method, various Java applications can be monitored, so that the running safety of the Java applications and products is ensured.

Description

Java application monitoring method and device, storage medium and electronic equipment

Technical Field

The invention relates to the technical field of computers, in particular to a Java application monitoring method and device, a storage medium and electronic equipment.

Background

Java applications and products are systems developed based on Java programming language, and since Java programming has many advantages such as portability, extensibility, etc., Java applications and products are widely developed and used.

Java applications and products run on tens of thousands of JVM instances and are important operation and maintenance objects. The JVM is monitored comprehensively and effectively, and is an important work in operation and maintenance management. However, in the prior art, the monitoring indexes for Java applications cannot be commonly used in various Java applications, and some key indexes are not monitored, so that monitoring is not in place easily, related operation risks cannot be discovered as early as possible, and further production faults are caused.

Disclosure of Invention

In view of this, the present invention provides a Java application monitoring method, by which various Java applications can be monitored, thereby ensuring the operational safety of Java applications and products.

The invention also provides a Java application monitoring device which is used for ensuring the realization and the application of the method in practice.

A Java application monitoring method comprises the following steps:

starting a preset monitoring acquisition script according to a preset time period;

collecting the currently and effectively running Java process by applying the monitoring collection script;

determining a monitoring object corresponding to the Java process, and setting a monitoring object name of the monitoring object;

collecting each monitoring index corresponding to the monitored object, and outputting a monitoring data file corresponding to each monitoring index to a preset monitoring tool;

applying the monitoring tool to perform data processing on the monitoring data file to obtain a processed monitoring data file;

judging whether the monitoring data file is abnormal or not based on a preset monitoring rule;

and if the monitored data file is abnormal, sending an alarm notice corresponding to the monitored object.

Optionally, the method for acquiring a currently and effectively running Java process by applying the monitoring acquisition script includes:

acquiring preset process information and extracting a first keyword contained in the process information;

acquiring a preset process list based on the first keyword, and detecting whether the process list comprises at least one Java process;

when the process list comprises at least one Java process, acquiring a preset blacklist;

and determining the effective Java process in the process list based on the blacklist, and collecting the effective Java process in the process list by applying the monitoring collection script.

Optionally, the setting of the name of the monitored object in the method includes:

determining the application type of a monitoring object corresponding to the Java process based on the first keyword;

extracting instance information of the application type;

when the instance information of the application type is successfully extracted, at least one second keyword is obtained from the instance information, an instance name is formed by each second keyword, and the second keyword is an instance keyword of a JVM instance corresponding to the Java process;

constructing a monitoring object name corresponding to the monitoring object based on the application type and the instance name;

when the instance information of the application type is failed to be extracted, port information of a monitoring port for monitoring the Java process is acquired;

and constructing a monitoring object name corresponding to the monitoring object based on the application type and the port information.

Optionally, the acquiring of each monitoring index corresponding to the monitored object includes:

acquiring a third keyword contained in the process information, wherein the third keyword is a log keyword used for determining whether a GC log exists or not;

determining whether a GC log of a JVM instance corresponding to the Java process exists or not based on the third key;

if a GC log of the JVM instance corresponding to the Java process exists, acquiring a FullGC monitoring index in a preset time period based on the GC log; the FullGC monitoring indexes comprise FullGC times, FullGC average consumed time, FullGC total consumed time, Heap utilization rate after FullGC and Heap recovery rate after FullGC;

if the GC log of the JVM instance corresponding to the Java process does not exist, determining a FullGC monitoring index in the preset time period based on FullGC monitoring index information contained in a preset temporary file;

applying a preset jstat command to obtain a Heap monitoring index of a Heap, wherein the Heap is a Heap memory of the Java process, and the Heap monitoring index comprises a Perm utilization rate, a Metaspace utilization rate and an Old utilization rate;

acquiring the maximum file possessed number capable of being opened of the Java process and the number of currently opened file handles;

and calculating the utilization rate of the opened file handles based on the maximum openable file handle number of the Java process and the current opened file handle number.

Optionally, the above method, wherein the obtaining of the FullGC monitoring index within the preset time period based on the GC log includes:

acquiring a GC log output path of the JVM instance, and acquiring a GC log based on the GC log output path;

determining a last scanning position recorded in the GC log, scanning the GC log by taking the last scanning position as an initial position, and obtaining the log content of the GC log in the preset time period;

and analyzing the content of the GC log to obtain a FullGC monitoring index in the preset time period.

Optionally, the determining the FullGC monitoring index within the preset time period based on the FullGC monitoring index information included in the preset temporary file includes:

acquiring historical FullGC monitoring indexes recorded when each monitoring index corresponding to the monitoring object is acquired last time and contained in the temporary file;

and determining a current FullGC monitoring index corresponding to the monitored object, and calculating the FullGC monitoring index in the preset time period based on the current FullGC monitoring index and the historical FullGC monitoring index.

Optionally, the above method, where the preset jstat command is applied to obtain a Heap monitoring index of the Heap, includes:

determining the perm area size and perm area use size of the largest perm area, the MetaSoce area size and MetaSoce area use size of the largest MetaSoce area, and the Old area size and Old area use size of the largest Old area in the JVM example;

calculating perm area usage of the perm area based on the perm area size and the perm area usage size;

calculating the usage rate of the Metasspace area based on the size of the Metasspace area and the usage size of the Metasspace area;

calculating an Old zone usage rate for the Old zone based on the Old zone size and the Old zone usage size.

A Java application monitoring apparatus, comprising:

the starting unit is used for starting a preset monitoring acquisition script according to a preset time period;

the first acquisition unit is used for acquiring a Java process of a preset server by applying the monitoring acquisition script;

the setting unit is used for determining a monitoring object corresponding to the Java process and setting a monitoring object name corresponding to the monitoring object;

the second acquisition unit is used for acquiring each monitoring index corresponding to the monitored object and outputting a monitoring data file corresponding to each monitoring index to a preset monitoring tool;

the processing unit is used for applying the monitoring tool to perform data processing on the monitoring data file to obtain a processed monitoring data file;

the judging unit is used for judging whether the monitoring data file is abnormal or not based on a preset monitoring rule;

and the alarm unit is used for sending an alarm notice corresponding to the monitored object if the monitored data file has abnormity.

A storage medium comprising stored instructions, wherein the instructions, when executed, control a device on which the storage medium is located to execute the Java application monitoring method as described above.

An electronic device comprising a memory, and one or more instructions, wherein the one or more instructions are stored in the memory and configured to be executed by one or more processors to perform the Java application monitoring method as described above.

Compared with the prior art, the invention has the following advantages:

based on the embodiment provided by the invention, in the process of monitoring the Java application, the preset monitoring acquisition script is started according to the preset time period, and the monitoring acquisition script is applied to acquire the currently and effectively running Java process; determining a monitoring object corresponding to the Java process, and setting a monitoring object name of the monitoring object; collecting each monitoring index corresponding to a monitored object, and outputting a monitoring data file corresponding to each monitoring index to a preset monitoring tool; applying a monitoring tool to perform data processing on the monitoring data file to obtain a processed monitoring data file; judging whether the monitoring data file is abnormal or not based on a preset monitoring rule; and if the monitored data file is abnormal, sending an alarm notice corresponding to the monitored object.

By applying the Java application monitoring method provided by the invention, various currently and effectively operated Java processes are collected through the monitoring collection script, various monitoring indexes of the monitoring object corresponding to each Java process are collected, and the monitoring tool is applied to process the various monitoring indexes to be collected so as to realize monitoring of various Java applications, thereby ensuring the operation safety of Java applications and products.

Drawings

In order to more clearly illustrate the embodiments of the present invention or the technical solutions in the prior art, the drawings used in the description of the embodiments or the prior art will be briefly described below, it is obvious that the drawings in the following description are only embodiments of the present invention, and for those skilled in the art, other drawings can be obtained according to the provided drawings without creative efforts.

Fig. 1 is a flowchart of a method for monitoring a Java application according to an embodiment of the present invention;

fig. 2 is a flowchart of another method of monitoring a Java application according to an embodiment of the present invention;

fig. 3 is a flowchart of another method of monitoring a Java application according to an embodiment of the present invention;

fig. 4 is a flowchart of another method of monitoring a Java application according to an embodiment of the present invention;

fig. 5 is a device structure diagram of a Java application monitoring device according to an embodiment of the present invention;

fig. 6 is a schematic structural diagram of an electronic device according to an embodiment of the present invention.

Detailed Description

The technical solutions in the embodiments of the present invention will be clearly and completely described below with reference to the drawings in the embodiments of the present invention, and it is obvious that the described embodiments are only a part of the embodiments of the present invention, and not all of the embodiments. All other embodiments, which can be derived by a person skilled in the art from the embodiments given herein without making any creative effort, shall fall within the protection scope of the present invention.

In this application, relational terms such as first and second, and the like are used solely to distinguish one entity or action from another entity or action without necessarily requiring or implying any actual such relationship or order between such entities or actions, and the terms "comprises", "comprising", or any other variation thereof are intended to cover a non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements does not include only those elements but may include other elements not expressly listed or inherent to such process, method, article, or apparatus. Without further limitation, an element defined by the phrase "comprising an … …" does not exclude the presence of other identical elements in a process, method, article, or apparatus that comprises the element.

JVM: is an abbreviation of JAVA Virtual Machine, which is an imaginary computer implemented by emulating various computer functions on a real computer. After the Java language virtual machine is introduced, the Java language needs to be recompiled when different platforms run. The Java language uses a Java virtual machine to shield information related to a specific platform, so that a Java reason compiler can be run on a variety of platforms without modification by only generating object codes (bytecodes) that run on the Java virtual machine.

Jmx (java Management extensions): is a framework for implanting management functions for applications. JMX is a standard proxy and service, and a user can monitor and manage the Java application and the JVM in any Java application by using the JMX. JMX has the following uses:

1) the running state of the application program and relevant statistical information are monitored.

2) The configuration of the application is modified (without requiring a reboot).

3) Notification processing when status changes or errors occur.

The related information of monitoring JAVA application programs and JVMs in JConsole and JVissualVM is realized by JMX. The JConsole monitors the heap memory usage, thread number and class number of the application program, checks some configuration information and even can dynamically modify the configuration.

JConsole (Java Monitoring and Management Console): the JMX-based visual monitoring and management tool is a JMX-based visual monitoring and management tool. JConsole is a management tool carried by JDK, and can be opened by directly operating JConsole under JAVA _ HOME/bin.

JConsole provides two ways of connecting, one is to connect to local processes and one is to connect to remote programs. The local connection does not need a password, and a corresponding JVM program is directly selected, and the remote connection is carried out through a JMX protocol.

The invention is operational with numerous general purpose or special purpose computing device environments or configurations. For example: personal computers, server computers, hand-held or portable devices, tablet-type devices, multi-processor apparatus, distributed computing environments that include any of the above devices or equipment, and the like.

The embodiment of the invention provides a method for monitoring Java application, which can be applied to a plurality of system platforms, wherein the execution main body of the method can be a computer terminal or a processor of various mobile devices, and the method has a flow chart as shown in figure 1 and specifically comprises the following steps:

s101: and starting a preset monitoring acquisition script according to a preset time period.

In the embodiment provided by the invention, the monitoring acquisition script can be called up on the server according to a certain execution frequency through a server crontab task or a monitoring tool (or other operation and maintenance tools). The acquisition frequency can be parameterized and configured as required, and the default acquisition frequency is as follows: once for 2 minutes.

S102: and acquiring the currently and effectively operated Java process by applying the monitoring acquisition script.

And collecting the Java processes on the server executed by the monitoring collection script according to the running monitoring collection script, wherein the Java processes comprise effectively running Java processes and ineffectively running Java processes, the ineffectively running Java processes are eliminated, and only the currently effectively running Java processes are collected.

Specifically, the acquiring, by applying the monitoring acquisition script, a currently and effectively running Java process includes:

In the embodiment provided by the invention, a Java process list corresponding to a first keyword is obtained by identifying the first keyword in the preset process information, if at least one Java process exists in the Java process list, each Java process in the Java process list is compared with the Java processes in the preset blacklist, the Java process which does not need to be monitored is identified, so that an effective Java process in the process list is determined, and the effective Java process in the process list is acquired by applying the monitoring acquisition script. If the Java process does not exist in the Java process list, subsequent acquisition actions do not need to be executed, and the acquisition execution is skipped.

The following is a program code implementation that obtains a list of Java processes that need to be monitored on a server by excluding extraneous Java processes.

# definition excluded monitoring Java Process List

V_EXCLUDE_JAVA_PROC＝"AppmonAgent|nft|NodeManager|JFServer"

# obtaining a list of Java processes that need to be monitored

ps-fu${USER}|grep-w"java"|grep-v"grep"|grep-Evw"${V_EXCLUDE_JAVA_PROC}"

The method has the advantages of self-adaption and maintenance-free, and supports automatic bringing of the monitored object into the monitoring range under the condition of no human intervention.

S103: and determining a monitoring object corresponding to the Java process, and setting a monitoring object name of the monitoring object.

In the embodiment provided by the invention, after the effective Java process is identified, the server where the Java process is located is used as a monitoring object. In order to ensure that the name of the monitoring object is unchanged after the Java process is restarted, so that the monitoring index continues to be connected according to the monitoring object, a relatively stable and unique name of the monitoring object needs to be defined for the monitoring object.

S104: and collecting each monitoring index corresponding to the monitoring object, and outputting a monitoring data file corresponding to each monitoring index to a preset monitoring tool.

S105: and applying the monitoring tool to perform data processing on the monitoring data file to obtain a processed monitoring data file.

And writing each index of the monitored object into a specified monitored data file according to the standard requirement. Therefore, the monitoring tool can scan the monitoring data file and collect the data of each monitoring index to the monitoring platform.

An example of an output file handle usage monitoring metric is as follows:

echo "cls < JAVA _ OPENFILES > obj < $ { V _ inst } > par < OPEN _ FILE _ RATIO > val < $ { V _ OPEN _ FILE _ RATIO } > > $ { V _ MONITOR _ LOG }, where:

the cls < JAVA _ OPENFLES > field defines the monitoring indicator type as: JAVA _ OPENFILLES (the number of file handles opened by a Java process), the obj < $ { v _ inst } > field defines the monitored object as: the par < OPEN _ FILE _ RATIO > field defines the output monitoring indicator as: OPEN _ FILE _ RATIO, val < $ { v _ OPEN _ FILE _ RATIO } > "field defines the monitoring object $ { v _ inst }, and the specific result value of the monitoring index OPEN _ FILE _ RATIO is: $ v _ open _ file _ ratio }.

S106: and judging whether the monitoring data file is abnormal or not based on a preset monitoring rule.

In the embodiment provided by the invention, the server calls the monitoring tool to enable the monitoring tool to periodically scan the storage directory of the monitoring file through the network management protocol agent deployed on the local computer, and newly generated acquisition result data is acquired to the monitoring platform. And the monitoring platform judges the abnormity of the monitoring data file according to a preset monitoring rule.

S107: and if the monitored data file is abnormal, sending an alarm notice corresponding to the monitored object.

The monitoring platform analyzes, cleans and processes the acquired data, judges whether the monitoring index of the monitored object is abnormal according to the defined monitoring alarm rule, and generates an alarm notice if the monitoring index of the monitored object is abnormal.

By calling the monitoring platform, the historical change curve of the monitoring index of each monitored object can be checked.

By applying the embodiment provided by the invention, various Java processes which are currently and effectively operated are collected through the monitoring collection script, each monitoring index of the monitoring object corresponding to each Java process is collected, and the monitoring tool is called to process each monitoring index to be collected, so that various Java applications are monitored, and the operation safety of the Java applications and products is ensured.

In the embodiment provided by the present invention, as shown in fig. 2, optionally, the setting of the monitoring object name of the monitoring object includes:

s201: and determining the application type of the monitoring object corresponding to the Java process based on the first keyword.

Defining a stable and unique name for the monitored object, extracting stability characteristic information from process information, permanently fixing the name of the monitored object, and ensuring that the name of the monitored object is not changed due to restart.

Specifically, the method can be implemented according to a naming rule of a unified monitoring object (JVM instance): < application type >: < instance name > to name the monitoring object. Therefore, the application type of the monitored object corresponding to the Java process needs to be determined according to the process information. The application type is used for distinguishing the type of the Java application product, such as: weblogic, Tomcat, coherence, WebSphere, etc. As shown in table 1, the Java process may be specifically distinguished by keywords corresponding to various product types in the process information, for example, if it is recognized that the keyword in the GC log is dweblogic.

Product name	Key word
		Weblogic	Dweblogic.Name
Tomcat	\-Dcatalina
		Coherence	DefaultCacheServer
Zookeeper	zookeeper
		Kafka	kafka
Websphere	Dwas

TABLE 1

S202: and judging whether the instance information of the application type is successfully extracted.

After the application type corresponding to the Java process is determined, corresponding instance information can be extracted according to the application type. An instance name is determined from the instance information.

When the instance information of the application type is successfully extracted, S203 to S204 are executed, and when the extraction of the instance information of the application type fails, S205 to S206 are executed.

S203: and acquiring at least one second keyword from the instance information, wherein the instance name is formed by each second keyword.

And the second keyword is an instance keyword of a JVM instance corresponding to the Java process.

Instance names may consist of one or more key concatenations with distinct instances, such as: a Weblogic Server name or a process listening port number, etc. may be used as a key to distinguish instances. So as to ensure that the names of the monitoring objects can be effectively distinguished.

S204: and constructing a monitoring object name corresponding to the monitoring object based on the application type and the instance name.

The application types of the instances can be named according to the characteristics of the products, that is, the product types, such as Weblogic, Tomcat, Zookeeper, and the like, to define different types of naming composition methods.

For example, for a Weblgoic instance, specific instance information can be further extracted according to the characteristics of Weblogic, including: the Domain name and the Server name to ensure that the monitoring object names can be effectively distinguished. Hence the name of Weblgoic can be made: weblogic: < Domain name > < Server name >.

S205: and acquiring port information of a monitoring port for monitoring the Java process.

If the instance information of the application type cannot be extracted, at least one second keyword in the instance information cannot be acquired to distinguish the instances. Because the monitor port of the process is relatively fixed, the original port is still used after the process is restarted, and therefore, the monitor port of the process can be obtained as a key for distinguishing the JVM examples.

S206: and constructing a monitoring object name corresponding to the monitoring object based on the application type and the port information.

The port information comprises port keywords and port numbers; and forming a monitoring object name corresponding to the monitoring object according to the application type and the port information. For example, for one Tomcat instance, the nomenclature consists of: tomcat: PORT _ 9001.

By extracting the stable characteristic information in the process information, such as the application type, the instance information, the port information and the like, and naming the monitoring object by using the extracted characteristic information, the name of the monitoring object is ensured not to be changed due to restart.

In the embodiment provided by the present invention, as shown in fig. 3, optionally, the acquiring each monitoring index corresponding to the monitored object includes:

s301: and acquiring a third key word contained in the process information, wherein the third key word is a log key word used for determining whether the GC log exists or not.

In the embodiment provided by the invention, the FullGC monitoring index can be obtained in two ways, the GC monitoring index is preferentially obtained through the GC log under the condition that the GC log exists, and the GC monitoring index is obtained through a jstat command under the condition that the GC log does not exist. Through the Xlogc key words in the process information, whether the GC log exists can be determined, and a GC log output path of the JVM instance can be extracted.

S302: and determining whether a GC log of the JVM instance corresponding to the Java process exists or not based on the third key.

And determining whether the GC log exists or not according to the Xlogc key words in the process information. If the GC log of the JVM instance corresponding to the Java process exists, executing S303; if there is no GC log of the JVM instance corresponding to the Java process, S304 is executed.

S303: and acquiring a FullGC monitoring index in a preset time period based on the GC log.

Wherein the FullGC monitoring indexes comprise FullGC times, FullGC average consumed time, FullGC total consumed time, Heap usage rate after FullGC and Heap recovery rate after FullGC.

FullGC is triggered to complete garbage collection under the condition that the space of an Old area or a Perm area in JVM Heap is not enough, the consumed time is long, and when the FullGC is carried out, a Java process suspends business processing, so that certain influence is caused on the business processing, such as long consumed time of the transaction, slow transaction processing and the like. Therefore, the number of FullGC is an index of the FullGC, and more indicates more system operation. The total time consumed by the FullGC is used as an index of the FullGC, and the total time consumed by the FullGC in the checking period is measured, wherein the longer the time is, the greater the influence on the service operation is.

S304: and determining the FullGC monitoring index in the preset time period based on FullGC monitoring index information contained in a preset temporary file.

Monitoring indexes such as FullGC times, FullGC total consumed time, FullGC average consumed time, Heap utilization rate after FullGC, FullGC Heap recovery rate and the like since the process is started during last collection are mainly recorded in the temporary file. FullGC monitoring index information recorded in the temporary file during the last acquisition from the process starting is calculated in a difference mode with FullGC times, FullGC total time consumption, FullGC average time consumption, FullGC post-Heap utilization rate, FullGC Heap recovery rate and other monitoring index information obtained during the current acquisition from the process starting, FullGC times, FullGC total time consumption, FullGC average time consumption, FullGC post-Heap utilization rate, FullGC Heap recovery rate and other monitoring index information in an acquisition time interval, and the FullGC monitoring index acquired at the current time is stored in the temporary file so that the calculation can be performed based on the FullGC monitoring index acquired at the current time during the next acquisition.

S305: and acquiring a Heap monitoring index of the Heap by using a preset jstat command.

The Heap is a Heap memory of the Java process, and a Heap monitoring index is a key index for evaluating whether the Heap has a capacity problem. The Heap monitoring index comprises Perm utilization rate, Metaspace utilization rate and Old utilization rate.

Specifically, the obtaining of the Heap monitoring index of the Heap by applying a preset jstat command includes:

determining a perm zone size and a perm zone use size of a largest perm zone, a MetaSopace zone size and a MetaSopace zone use size of a largest MetaSopace zone, and an Old zone size and an Old zone use size of a largest Old zone in the JVM example.

By jstat command: v _ max _ Perm _ size $ (jstat-gcpermcapacity $ { v _ pid } | grep-v "PGCMX" | awk '{ print $ (2) }' | awk-F "" '{ print $1}'), and obtaining JVM to define the maximum Perm region size;

then by jstat command: obtaining the current Perm area use size by using v _ used $ (jstat-gc $ { v _ pid } | grep-v "PU" | awk '{ print $ (NF-5) }' | awk-F "" '{ print $1 }'); similarly, by the jstat command: v _ max _ meta _ size $ (jstat-gcmaetacapaccess $ { v _ pid } | grep-v "MCMX" | awk '{ print $ (2) }' | awk-F "" '{ print $1}'), and obtaining JVM to define the maximum MetaSpace area size;

then by jstat command: obtaining the current Metaservice area usage size by using v _ used $ (jstat-gc $ { v _ pid } | grep-v ' MU "| awk ' { print $ (NF-7) } ' | awk-F ' { print $1} ');

similarly, by the jstat command: v _ max _ Old _ size $ (jstat-gc $ { v _ pid } | grep-v "PU" | awk '{ print $ (7) }' | awk-F "" '{ print $1}'), and obtaining the Old area size;

then by jstat command: v _ used $ (jstat-gc $ { v _ pid } | grep-v "PU" | awk '{ print $ (8) }' | awk-F "" '{ print $1}'), and the current Old region usage size is obtained.

And calculating the perm area utilization rate of the perm area based on the perm area size and the perm area utilization size.

The Perm usage rate is calculated by v _ ratio $ (echo "100 $ { v _ used }/$ { v _ max _ Perm _ size }/1024" | bc).

If the Perm utilization rate is greater than or equal to 95%, a primary warning is issued, and if the Perm utilization rate is greater than or equal to 85%, a secondary warning is issued.

And calculating the usage rate of the Metaspace area based on the size of the Metaspace area and the usage size of the Metaspace area.

The MetaSpace zone usage rate is calculated by v _ ratio $ (echo "100 $ { v _ used }/$ { v _ max _ meta _ size }/1024" | bc).

And if the usage rate of the Metaspace area is greater than or equal to 95%, a primary warning is sent out, and if the usage rate of the Metaspace area is greater than or equal to 85%, a secondary warning is sent out.

The Old zone usage is calculated by v _ ratio $ (echo "100 $ { v _ used }/$ { v _ max _ Old _ size }/1024" | bc).

If the Old zone usage is greater than or equal to 95%, a secondary warning is issued.

S306: and acquiring the maximum file possessed number capable of being opened of the Java process and the number of currently opened file handles.

Specifically, the maximum number of file handles that can be opened by the Java process can be obtained through/proc/< PID >/limits, and the specific command is as follows: v _ Max _ open _ files $ (grep "Max open files"/proc/$ { v _ pid }/limits | awk '{ print $4 }'); acquiring the number of the currently opened file handles of the Java process through/proc/< PID >/fd, wherein the specific command is as follows: v _ open _ files ═ $ (ls/proc/$ { v _ pid }/fd | wc-l).

S307: and calculating the utilization rate of the opened file handles based on the maximum openable file handle number of the Java process and the current opened file handle number.

Based on the obtained maximum openable file handle number v _ max _ open _ files and the current openable file handle number v _ open _ files, calculating the utilization rate v _ open _ file _ ratio of the opened file handle, wherein the command is as follows:

v_open_file_ratio＝$(echo"${v_open_files}*100/${v_max_open_files}"|bc)。

relevant monitoring indexes such as FullGC, the number of handles of process-opened files, Perm/MetaSlace utilization rate and the like are completed and effectively monitored, so that relevant risks can be found in time in the operation stage, relevant problems are solved, and the completeness of Java monitoring is improved.

In the embodiment of the present invention, optionally, the obtaining a FullGC monitoring index within a preset time period based on the GC log includes:

and acquiring a GC log output path of the JVM instance, and acquiring a GC log based on the GC log output path.

Through the third keyword, that is, the xlogc keyword, included in the process information, the GC log output path of the JVM instance can be extracted, and the corresponding GC log is obtained according to the obtained GC log output path.

And determining the last scanning position recorded in the GC log, scanning the GC log by taking the last scanning position as an initial position, and obtaining the log content of the GC log in the preset time period.

And recording the last position of the GC log scanned by the monitoring check after each monitoring check is finished, and when the check is carried out within a preset time period, scanning the GC log by taking the position as the initial position according to the recorded last position scanned last time so as to read the log content within the preset time period. If the last location of the last scan is not available, e.g., the first time a monitoring check is performed, then the last location of the last scan is defaulted to be the last line of the GC log.

And analyzing the content of the GC log in the preset time period as the check period to obtain the FullGC monitoring index of the check period. Specifically, the method comprises the following steps:

counting the occurrence frequency of FullGC in the checking period to obtain the frequency of FullGC;

accumulating the consumed time of each FullGC in the inspection period to obtain the total consumed time of the FullGC;

obtaining the average FullGC consumption time by dividing the total FullGC consumption time by the FullGC times;

reading the last row of FullGC logs in the scanning range, extracting the actual size of the Heap from the logs, and the using size of the Heap after the FullGC, and calculating to obtain the utilization rate of the Heap after the FullGC, wherein the calculation formula is FullGC Heap recovery rate (the using size of the Heap before the FullGC-the using size of the Heap after the FullGC)/(the actual size of the Heap), the FullGC Heap recovery rate is used for evaluating whether the FullGC can effectively carry out Heap recovery, judging whether the monitored data file is abnormal or not according to each data obtained by calculation, and if so, sending corresponding alarm information.

For example, if the monitoring acquisition script is executed every 2 minutes by default, a primary warning is issued if the number of FullGC times in the check period is greater than or equal to 10, and a secondary warning is issued if the number of FullGC times in the check period is greater than or equal to 5; sending out a primary warning when the average FullGC consumption time is more than or equal to 8, and sending out a secondary warning when the average FullGC consumption time is more than or equal to 4; when the total consumption time of the FullGC is more than or equal to 20, a main warning is sent out, and when the total consumption time of the FullGC is more than or equal to 10, a secondary warning is sent out; after the FullGC, if the Heap use rate is more than or equal to 95, a primary warning is sent out, and if the Heap use rate is more than or equal to 90, a secondary warning is sent out; a primary warning is issued when the FullGC Heap recovery rate is less than or equal to 2, and a secondary warning is issued when the FullGC Heap recovery rate is less than or equal to 5.

And acquiring a GC log through a GC log output path, recording the last scanning position recorded in the GC log, and scanning the GC log from the last scanning position as a starting position so as to obtain the log content of the GC log in a preset time period, and analyzing the log content, thereby obtaining the FullGC monitoring index in the preset time period.

In the embodiment provided by the present invention, optionally, the determining the FullGC monitoring index within the preset time period based on the FullGC monitoring index information included in the preset temporary file includes:

specifically, the last recorded number of FullGC times, local v _ gc _ count _ last, is obtained by the following specific command: local V _ gc _ count _ last $ (grep-w "$ { V _ pid }" $ { V _ JSTAT _ TMP _ FILE } | awk-F "|" '{ print $2}' | head-n 1);

obtaining the total FullGC time consumption local v _ gc _ time _ last recorded last time, wherein the specific command is as follows: local V _ gc _ time _ last $ (grep-w "$ { V _ pid }" $ { V _ JSTAT _ TMP _ FILE } | awk-F "|" '{ print $3}' | head-n 1).

Specifically, the current FullGC frequency local v _ gc _ count _ now is obtained, and the specific command is as follows: local v _ gc _ count _ now $ (jstat-gc $ { v _ pid } | grep-v "MU" | awk ' { print $ (NF-2) } ' | awk-F "" ' { print $1 });

acquiring the current FullGC frequency local v _ gc _ time _ now, wherein the specific command is as follows: local v _ gc _ time _ now $ (jstat-gc $ { v _ pid } | awk '{ print $ (NF-1) }' | awk-F "" '{ print $1 }');

the number of FullGC times in the time interval, i.e., the number of FullGC times, i.e., v _ Fullgc _ count $ (echo), is obtained by calculation

"${v_gc_count_now}-${v_gc_count_last}"|bc)local v_fullgc_count；

Obtaining the total consumed time of the FullGC within the time interval, i.e. local v _ FullGC _ totaltime $ (echo "$ { v _ gc _ time _ now } - $ { v _ gc _ time _ last }" | bc), through calculation;

finally, the average time consumption v _ FullGC _ avgtime $ (echo) of the FullGC is obtained through calculation

"${v_fullgc_totaltime}/${v_fullgc_count}"|bc)。

As shown in fig. 4, in a specific embodiment provided by the present invention, when monitoring various Java applications, first, a monitoring script is scheduled and executed in a server that needs to be monitored at regular time, or the monitoring script is executed once in default 5 minutes to obtain each Java process running in the server, so as to form a Java process list, where each Java process is a JVM instance and corresponds to a monitoring object. If the server has Java processes, defining the names of the monitoring objects corresponding to the Java processes according to the Java processes, so as to avoid that the names of the monitoring objects are changed after the Java processes are restarted, which may be specifically according to < application type >: the method comprises the following steps that (1) an < example name > rule or a monitoring object name is defined through a monitoring port, after the monitoring object name is definite, the operation index of the monitoring object is further collected, and the monitoring index mainly comprises the following steps: FullGC, Heap use, open File handle number. And outputting the collected monitoring indexes to a specified monitoring index data file in a formatted manner according to the standard requirement, so that a monitoring tool can scan the monitoring index data file, collect each formatted monitoring index data to a monitoring platform, and process the collected monitoring index data by the monitoring tool, wherein the process comprises the steps of calculating each monitoring index data, displaying each monitoring index data, judging whether abnormal monitoring index data exist or not, and generating an alarm notification if the abnormal monitoring index data exist.

The specific implementation procedures and derivatives thereof of the above embodiments are within the scope of the present invention.

Corresponding to the method described in fig. 1, an embodiment of the present invention further provides a Java application monitoring apparatus, which is used for implementing the method in fig. 1 specifically, and the Java application monitoring apparatus provided in the embodiment of the present invention may be applied to a computer terminal or various mobile devices, and a schematic structural diagram of the apparatus is shown in fig. 5, and specifically includes:

a starting unit 501, configured to start a preset monitoring acquisition script according to a preset time period;

a first collecting unit 502, configured to collect a Java process of a preset server by using the monitoring collection script;

a setting unit 503, configured to determine a monitored object corresponding to the Java process, and set a monitored object name corresponding to the monitored object;

a second collecting unit 504, configured to collect each monitoring index corresponding to the monitored object, and output a monitoring data file corresponding to each monitoring index to a preset monitoring tool;

a processing unit 505, configured to apply the monitoring tool to perform data processing on the monitoring data file, so as to obtain a processed monitoring data file;

a determining unit 506, configured to determine whether the monitored data file is abnormal based on a preset monitoring rule;

and an alarm unit 507, configured to send an alarm notification corresponding to the monitored object if the monitored data file is abnormal.

Based on the Java application monitoring device provided by the invention, in the process of monitoring the Java application, the starting unit starts a preset monitoring acquisition script according to a preset time period, and the first acquisition unit applies the monitoring acquisition script to acquire the currently and effectively running Java process; the setting unit determines a monitoring object corresponding to the Java process and sets a monitoring object name of the monitoring object; the second acquisition unit acquires each monitoring index corresponding to the monitored object and outputs a monitoring data file corresponding to each monitoring index to a preset monitoring tool; the processing unit applies the monitoring tool to perform data processing on the monitoring data file to obtain a processed monitoring data file; based on a preset monitoring rule, the judging unit judges whether the monitoring data file is abnormal or not; and if the monitored data file is abnormal, the alarm unit sends an alarm notice corresponding to the monitored object.

By applying the device provided by the invention, various Java processes which are currently and effectively operated are collected through the monitoring collection script, various monitoring indexes of the monitoring object corresponding to each Java process are collected, and each monitoring index to be collected is processed by applying the monitoring tool, so that various Java applications are monitored, and the operation safety of the Java applications and products is ensured.

The specific working processes of each unit and sub-unit in the Java application monitoring apparatus disclosed in the above embodiment of the present invention may refer to corresponding contents in the Java application monitoring method disclosed in the above embodiment of the present invention, and are not described herein again.

The embodiment of the invention also provides a storage medium, which comprises a stored instruction, wherein when the instruction runs, the device where the storage medium is located is controlled to execute the Java application monitoring method.

An electronic device is provided in an embodiment of the present invention, and the structural diagram of the electronic device is shown in fig. 6, which specifically includes a memory 601 and one or more instructions 602, where the one or more instructions 602 are stored in the memory 601 and configured to be executed by one or more processors 603 to perform the following operations on the one or more instructions 602:

The embodiments in the present specification are described in a progressive manner, and the same and similar parts among the embodiments are referred to each other, and each embodiment focuses on the differences from the other embodiments. In particular, the system or system embodiments are substantially similar to the method embodiments and therefore are described in a relatively simple manner, and reference may be made to some of the descriptions of the method embodiments for related points. The above-described system and system embodiments are only illustrative, wherein the units described as separate parts may or may not be physically separate, and the parts displayed as units may or may not be physical units, may be located in one place, or may be distributed on a plurality of network units. Some or all of the modules may be selected according to actual needs to achieve the purpose of the solution of the present embodiment. One of ordinary skill in the art can understand and implement it without inventive effort.

Those of skill would further appreciate that the various illustrative elements and algorithm steps described in connection with the embodiments disclosed herein may be implemented as electronic hardware, computer software, or combinations of both.

To clearly illustrate this interchangeability of hardware and software, various illustrative components and steps have been described above generally in terms of their functionality. Whether such functionality is implemented as hardware or software depends upon the particular application and design constraints imposed on the implementation. Skilled artisans may implement the described functionality in varying ways for each particular application, but such implementation decisions should not be interpreted as causing a departure from the scope of the present invention.

The previous description of the disclosed embodiments is provided to enable any person skilled in the art to make or use the present invention. Various modifications to these embodiments will be readily apparent to those skilled in the art, and the generic principles defined herein may be applied to other embodiments without departing from the spirit or scope of the invention. Thus, the present invention is not intended to be limited to the embodiments shown herein but is to be accorded the widest scope consistent with the principles and novel features disclosed herein.

Claims

1. A Java application monitoring method is characterized by comprising the following steps:

2. The method of claim 1, wherein said applying the monitor collection script to collect Java processes currently running actively comprises:

3. The method according to claim 2, wherein the setting of the monitoring object name of the monitoring object comprises:

extracting instance information of the application type;

4. The method according to claim 1, wherein the collecting of each monitoring index corresponding to the monitored object comprises:

5. The method of claim 4, wherein the obtaining FullGC monitoring index within a preset time period based on the GC log comprises:

6. The method according to claim 4, wherein the determining the FullGC monitoring index within the preset time period based on FullGC monitoring index information contained in the preset temporary file comprises:

7. The method according to claim 4, wherein the applying a preset jstat command to obtain a Heap monitoring index of a Heap comprises:

8. A Java application monitoring apparatus, comprising:

9. A storage medium comprising stored instructions, wherein the instructions, when executed, control a device on which the storage medium is located to execute the Java application monitoring method according to any one of claims 1 to 7.

10. An electronic device comprising a memory, and one or more instructions stored in the memory and configured to be executed by one or more processors to perform the Java application monitoring method of any one of claims 1-7.