Services software process monitoring method based on heterogeneous graph generation rule

Abstract

The invention discloses a service software process monitoring method based on a heterogeneous graph generation conversion rule. The method comprises the following steps: determining a dependency relationship between classes and methods in a service byte code file; constructing a dependency relationship analysis tool by using an ASM byte code operation library, and extracting a complete class name of each program class, a method name in each program class and a dependency relationship between the class and the method; constructing a directory tree and a dependency heterogeneous graph; selecting a target object through the directory tree, and extracting a dependency relationship related to the target object from the dependency relationship heterogeneous graph to form a dependency relationship sub-graph; an Agent program is used for analyzing the dependency relationship subgraph to form an instrumentation object rule text, then a rule text address is transmitted to an instrumentation program, and the instrumentation program is loaded to a tested service JVM; analyzing the rule text into classes and methods with a mapping relationship, reloading the successfully matched classes, and directionally modifying byte codes of the successfully matched methods; calling the tested service access interface, obtaining a program running log after the interface is called, and verifying the instrumentation effect. According to the invention, the dependency relationship analysis efficiency of the tested service is improved.

Description

Technical Field

[0001] The present invention relates to software detection and evaluation technology, and in particular to a service-oriented software process monitoring method based on heterogeneous graph generation rules. Background Art

[0002] With the development of information technology, the scale of service software is getting larger and larger, and the application environment is becoming more and more complex. In order to standardize the quality of service-oriented software development throughout its life cycle, the country has issued a series of standards to constrain the development process of service-oriented software, such as "GB / T 8566-2007 Information Technology Software Life Cycle Process". How to use information technology to verify the compliance of software standards is of great significance to promoting the implementation of relevant standards and ensuring the quality of software development. For the action behavior of running software, process monitoring and analysis technology is usually used to monitor the running process of the software without affecting the execution status of the software under test, and carry out dynamic behavior compliance testing.

[0003] Agent technology is an important concept in the field of software engineering. JavaAgent, also known as Java probe technology, supports adding specified bytecodes to compiled Java classes. The dynamic agent program for JavaAgent (hereinafter referred to as "Agent program") provides a bytecode plug-in entry to the outside by establishing an access interface, and runs the plug-in program directly on the JVM of the running Java service under test, thereby modifying the bytecode of the service under test. The plug-in program completes zero-intrusive modification and reloading of the Java service under test through the access interface provided by the Agent program. The dynamic program agent technology for JavaAgent has been widely used, such as Aspect Orient Programming (AOP) in the Java Spring framework, which dynamically adds unified additional functions to the service without modifying the source code. It is very helpful for software detection and defect location of complex systems, and can greatly improve the efficiency of locating and repairing problems.

[0004] However, the existing dynamic program proxy technology for JavaAgent has problems that affect the overall performance in the instrumentation application. The existing technical methods mainly have the following problems: First, the Agent program does not limit the operating scope of the bytecode class of the service under test. Therefore, if the instrumentation program is loaded directly through the Agent program, all loaded classes of the service under test will be instrumented, which consumes the instrumentation execution time of irrelevant programs and increases the performance loss of the system under test. Second, the filtering class rules of the bytecode class are configured for the Agent program through external parameters, the operating scope of the bytecode class is manually configured, the bytecode class is converted and the bytecode class of the converted class is executed. This process requires clarifying the calling relationship between the classes or methods of the service under test. For external testers, it is very troublesome to obtain the source code and identify the calling relationship between the classes or methods in the source code. Summary of the invention

[0005] The purpose of the present invention is to propose a service-oriented software process monitoring method based on heterogeneous graph generation rules.

[0006] The technical solution to achieve the purpose of the present invention is: a service-oriented software process monitoring method based on heterogeneous graph generation conversion rules, comprising the following steps:

[0007] S1, establish the dependency relationship between classes and methods in the service bytecode file, including class dependency class, method dependency class and method dependency method;

[0008] S2, based on the established dependencies, use the ASM bytecode manipulation library to build a dependency parsing tool to extract the complete class name of each program class, the method name in each program class, and the dependencies between classes and methods;

[0009] S3, builds a directory tree based on the hierarchical relationship between classes and methods;

[0010] S4, constructs a heterogeneous dependency graph based on the two nodes of program class and program method, as well as the dependency relationship between class and method;

[0011] S5, select the target object through the directory tree, and extract the dependency related to the target object from the dependency heterogeneous graph to form a dependency subgraph;

[0012] S6, using the Agent program to parse the dependency subgraph to form the instrumentation object rule text, then passing the rule text address to the instrumentation program, and loading the instrumentation program onto the JVM of the service under test;

[0013] S7, after receiving the address parameter, the instrumentation program parses the rule text into classes and methods with mapping relationships, reloads the successfully matched classes, and makes targeted modifications to the bytecodes of the successfully matched methods;

[0014] S8, after completing the instrumentation, call the tested service access interface, obtain the program running log after the interface call, and verify the instrumentation effect.

[0015] Further, S2, based on the established dependencies, uses the ASM bytecode operation library to build a dependency parsing tool, the specific method is as follows:

[0016] Step 2.1: Use the binary combination of (package name, class name) as the unique identifier for a program class, and the quadruple combination of (package name, class name, method name, method descriptor) as the unique identifier for a program method, where the method descriptor is a string consisting of the method name, parameter type list, and return value type;

[0017] Step 2.2: Based on the ASM bytecode operation library, deep analysis of program classes is implemented. The ASM bytecode operation library is used to traverse the dependencies between classes. The dependencies between classes include inheritance, implementation, association, and aggregation. At the same time, the dependencies at the program method level are traversed within the class. The dependencies at the program method level include reference, call, and declaration relationships, and the program's unique identifier is used to establish a ternary relationship group of (program identifier A, program identifier B, dependency).

[0018] Furthermore, S3 builds a directory tree based on the hierarchical relationship between classes and methods, where:

[0019] The hierarchical relationship between classes and methods includes the hierarchy of the packages to which the classes belong in the program and the hierarchy of the methods contained in the classes;

[0020] The nodes of the directory tree include three levels: packages, classes, and methods. The relationship between the three levels is a parent-child relationship. The class is the child node of the package to which it belongs, and the method in the class is the child node of the class.

[0021] Furthermore, S4 constructs a dependency heterogeneous graph based on the two nodes of program class and program method, as well as the dependency relationship between class and method. The specific method is as follows:

[0022] Taking the first element of the triple as the starting point, the second element as the end point, and the third element as the connection relationship, a heterogeneous dependency graph consisting of two types of nodes, program class and program method, and multiple connection relationships between them is established. Different dependency relationships between nodes are represented by different types of edges.

[0023] Further, S5, a target object is selected through the directory tree, and dependencies related to the target object are extracted from the dependency heterogeneous graph to form a dependency subgraph. The specific method is as follows:

[0024] Select a program class node or program method node from the directory tree formed by S3, identify the unique identifier of the node, locate the node corresponding to the identifier from the heterogeneous graph network formed by S4, and traverse the graph according to the selected expected dependency relationship through the breadth-first algorithm to obtain the nodes connected to the starting point and form a dependency subgraph.

[0025] Further, S7, after receiving the address parameter, the plug-in program parses the rule text into classes and methods with mapping relationships, reloads the matched classes, and makes targeted modifications to the bytecodes of the matched methods, where:

[0026] The parsing rule text is a class and method with a mapping relationship, where the mapping relationship refers to a key-value pair from a class identifier to a method identifier list, and the mapping relationship includes the target program that needs to be reloaded this time;

[0027] Reloading the matched classes and making targeted modifications to the bytecodes of the matched methods is a process in which, after obtaining the bytecode file of the class corresponding to the key in the mapping relationship, the ASM bytecode operation library is used to perform targeted instrumentation on the program of the method list corresponding to the value, complete the custom modification, and reload the modified bytecode on the JVM.

[0028] Further, S8, after the instrumentation is completed, the tested service access interface is called, and the program running log after the interface call is obtained to verify the instrumentation effect, wherein:

[0029] If the accessed interface is the target program interface, the verification operation log should be the modified program execution log. If the accessed interface is not the target program interface, the verification operation log is still the previous program execution log.

[0030] A service-oriented software process monitoring system based on heterogeneous graph generation conversion rules implements the service-oriented software process monitoring method based on heterogeneous graph generation conversion rules to achieve service-oriented software process monitoring based on heterogeneous graph generation conversion rules, and is divided into eight modules to execute s1 to s8.

[0031] A computer device includes a memory, a processor, and a computer program stored in the memory and executable on the processor. When the processor executes the computer program, the service-oriented software process monitoring method based on heterogeneous graph generation conversion rules is implemented to realize service-oriented software process monitoring based on heterogeneous graph generation conversion rules.

[0032] A computer-readable storage medium stores a computer program. When the computer program is executed by a processor, the service-oriented software process monitoring method based on heterogeneous graph generation conversion rules is implemented to realize service-oriented software process monitoring based on heterogeneous graph generation conversion rules.

[0033] Compared with the prior art, the present invention has the following significant advantages: 1) By performing static dependency analysis on the bytecode file of the service under test, the dependency relationship between classes or methods is identified, and a heterogeneous dependency graph is constructed. Combined with the idea of ​​breadth-first traversal in graph theory, the complete dependency relationship between classes or methods can be extracted, which can solve the problem of inconvenient acquisition of the source code of the service under test and the difficulty in identifying the dependency relationship from the source program, and improve the efficiency of dependency analysis of the service under test. 2) During the service running state loading process, the heterogeneous dependency graph obtained by static dependency analysis can narrow the scope of plugging of the service under test, accurately reload the target program and its calling program, and effectively reduce the performance loss caused to the running state service compared with full plugging. BRIEF DESCRIPTION OF THE DRAWINGS

[0034] Figure 1 It is the technical roadmap of the present invention;

[0035] Figure 2 It is the program structure analysis and dependency relationship analysis diagram of the present invention;

[0036] Figure 3 It is a flow chart for extracting instrumented objects based on dependency graph;

[0037] Figure 4 It is the instrumentation flow chart;

[0038] Figure 5 It is a flow chart of instrumentation program directed reloading. DETAILED DESCRIPTION

[0039] In order to make the purpose, technical solution and advantages of the present application more clearly understood, the present application is further described in detail below in conjunction with the accompanying drawings and embodiments. It should be understood that the specific embodiments described herein are only used to explain the present application and are not used to limit the present application.

[0040] The present invention proposes a service-oriented software process monitoring and analysis method based on heterogeneous graph generation conversion rules, which performs running-state proxy control on the tested service based on JavaAgent-oriented dynamic proxy technology, and then controls and modifies the bytecode of the service loaded class, implements the plugging of the running-state software and outputs the execution call chain information, thereby monitoring the execution process of the tested service. In this process, through the static dependency analysis technology oriented to bytecode, the dependency capture to the method granularity is realized, and a dependency heterogeneous graph containing two granularities of class and method is established, and the conversion rules of the bytecode class are generated based on the dependency heterogeneous graph, thereby achieving the optimization goal of generating filtering class rules before process monitoring and analysis. With text as the carrier, static dependency analysis and dynamic plugging agent are connected, and finally accurate plugging of the detected program and its calling program is realized, that is, the execution process monitoring record of the tested service can be completed, and at the same time, the manpower and performance loss caused by the full scanning and analysis of the source code is also compensated.

[0041] Figure 1 This is the technical roadmap of the invention. A technical route for a service-oriented software process monitoring method based on heterogeneous graph generation conversion rules includes 8 stages: S1, establishing the dependency relationship between classes and methods in the service bytecode file, including the dependency relationship between classes, methods, and classes; S2, using the ASM bytecode operation library to build a parsing tool based on the established dependency relationship; S3, parsing the directory structure of the tested service and establishing a directory tree; S4, parsing all the dependencies of the tested service and establishing a global dependency heterogeneous graph; S5, selecting the target object through the directory tree and extracting the target object from the dependency heterogeneous graph. The process of forming a dependency subgraph by building object-related dependencies; S6, the Agent program parses the dependency subgraph, forms the instrumentation object rule text and passes the rule text address to the instrumentation program, and loads the instrumentation program onto the JVM of the service under test; S7, after receiving the address parameter, the instrumentation program parses the rule text into matching objects such as classes and methods with mapping relationships, reloads the classes that pass the match, and makes targeted modifications to the bytecodes of the methods that pass the match; S8, after completing the instrumentation, call the access interface of the service under test, obtain the program running log after the interface call, and verify the instrumentation effect. If the accessed interface is the target program interface, verify that the running log should be the modified program execution log. If the accessed interface is not the target program interface, verify whether the running log is still the previous program execution log.

[0042] Figure 2It is a program structure parsing and dependency parsing diagram. A parsing tool is built based on the ASM bytecode operation library to parse the structure and content of the bytecode file package. First, the complete class name of each program class is extracted in the form of a combination of the package name and the class name, and the method name in each program class is extracted. On this basis, the hierarchical relationship between the class and the method is extracted, and a directory tree is constructed according to the tree structure. Among them, the hierarchical relationship between the class and the method includes the hierarchy of the package to which the class belongs in the program and the hierarchy of the method contained in the class; the nodes of the directory tree include three levels: package, class and method. The relationship between the three levels is a parent-child relationship. The class is the child node of the package to which it belongs, and the method in the class is the child node of the class. The dependency relationship between the class and the method is extracted, and a heterogeneous dependency graph is constructed according to the graph structure. Among them, the dependency relationship includes class dependency class, method dependency class, method dependency method and other dependencies. The dependency relationships of different services under test will be different. Class dependency classes include inheritance relationships, implementation relationships, association relationships, and aggregation relationships between classes; method dependency classes include parameter types, return value types, and variable types defined or declared in methods; method dependency methods include method call methods. The nodes of the dependency heterogeneous graph include classes and methods. The combination of package name and class name is used as the unique identifier of class nodes, and the package name, class name, and method descriptor are combined as the unique identifier of method nodes. The method descriptor is a string consisting of the method name, parameter type list, and return value type. Different dependency relationships between nodes are represented by different types of edges to form a heterogeneous graph network.

[0043] Figure 3 It is based on the dependency graph to extract the instrumentation object flow chart. Select a certain type of node or method node from the directory tree formed by S3, identify the unique identifier of the node, locate the node corresponding to the identifier from the heterogeneous graph network formed by S4, and extract the dependency subgraph containing the node through the breadth-first algorithm. Convert the Euclidean space information of the dependency subgraph into text information to form the instrumentation object rule text.

[0044] Figure 4 It is a plug-in flow chart. The Agent program is used to identify the plug-in object (target program such as class or method) and pass the plug-in object address to the plug-in program to implement the plug-in process. The plug-in program identifies the plug-in object and modifies the plug-in object. Then the Agent program reloads the class where the plug-in object is located to perform the plug-in operation.

[0045] Figure 5This is the flow chart of the rule matching reloading performed by the instrumentation program. The instrumentation program reads the rule text and parses the rule text into a collection with a mapping relationship. The mapping relationship refers to the key-value pair from the class identifier to the method identifier list. The mapping relationship contains the target program that needs to be reloaded this time. Rule matching reloading is the process of obtaining the bytecode file of the class corresponding to the key in the mapping relationship, using the ASM bytecode operation library to perform targeted instrumentation on the program of the method list corresponding to the value, completing the custom modification, and reloading the modified bytecode on the JVM.

[0046] Example

[0047] In order to verify the effectiveness of the present invention, the following simulation experiment is carried out.

[0048] The specific execution steps of a service-oriented software process monitoring technology based on heterogeneous graph generation rules are described as follows.

[0049] Step 1: Determine the dependencies of the tested services. In this process, the dependencies between the tested service classes or methods are established, and the program dependencies that will appear in the project are integrated to build a more comprehensive dependency heterogeneous graph model.

[0050] Step 2: Build a dependency analysis tool. Build a parsing tool to analyze the dependencies between these programs based on the established relationships.

[0051] Step 2.1: Use the binary combination of (package name, class name) as the unique identifier for a program class, and use the quadruple combination of (package name, class name, method name, method description) as the unique identifier for a program method.

[0052] Step 2.2: Implement deep analysis of program classes based on the ASM bytecode manipulation library. For program classes, use the ASM bytecode manipulation library to traverse the implementation, inheritance, association, aggregation and other dependencies between classes. At the same time, traverse the reference, call, declaration and other dependencies at the program method level within the class, and use the program's unique identifier to establish a ternary relationship group of (program identifier A, program identifier B, dependency).

[0053] Step 3: Analyze the program structure relationship and build a program directory tree. Based on the unique identifiers of program classes and program methods extracted by the dependency analysis tool in Step 2, establish the superior-subordinate relationship of the program and build a directory tree according to the tree structure.

[0054] Step 4: Establish a heterogeneous dependency graph. Restructure the structure based on the triple relationship group extracted by the dependency parsing tool in Step 2. The triples are program identifier A, program identifier B, and program dependency. The first element of the triple is used as the starting point, the second element as the end point, and the third element as the connection relationship. Establish a heterogeneous dependency graph consisting of two types of nodes: program class and program method, and multiple connection relationships between them.

[0055] Step 5: Select the target program in the directory tree and extract the dependency subgraph from the dependency heterogeneous graph. Select a program and the expected dependency in the directory tree, obtain the unique identifier of the program, and use the program node corresponding to the unique identifier as the starting point in the dependency heterogeneous graph. Use the breadth-first algorithm to traverse the graph according to the selected expected dependency, obtain the nodes connected to the starting point and having the dependency, and form a dependency subgraph.

[0056] Step 6: The proxy control program parses the dependency subgraph.

[0057] Step 6.1: The proxy control program parses the dependency subgraph and obtains the program class node or program method node in the graph.

[0058] Step 6.2: Parse the unique identifier of the obtained node and adapt it to the format recognized by JVM class loading.

[0059] Step 6.3: Write the program identifiers of all adapted nodes into the rule text and record the rule text address.

[0060] Step 7: The instrumentation program reads the reloaded class and instrumentation object. The proxy control program receives the instruction, passes the rule text address to the instrumentation program, and attaches the instrumentation program to the service-oriented software system under test. The instrumentation program traverses each line of rule text as an object of program class reload, and performs bytecode modification on each reloaded program object according to the bytecode modification program based on ASM. After the modification is completed, the modified bytecode class file is reloaded in the JVM.

[0061] Step 8: Call the interface that is consistent with or has a dependency relationship with the target program selected in the service directory tree under test, obtain the program running log after the interface is called, and verify whether the running log is the modified program execution log.

[0062] The technical features of the above embodiments may be combined arbitrarily. To make the description concise, not all possible combinations of the technical features in the above embodiments are described. However, as long as there is no contradiction in the combination of these technical features, they should be considered to be within the scope of this specification.

[0063] The above-described embodiments only express several implementation methods of the present application, and the descriptions thereof are relatively specific and detailed, but they cannot be understood as limiting the scope of the present application. It should be pointed out that, for a person of ordinary skill in the art, several variations and improvements can be made without departing from the concept of the present application, and these all belong to the protection scope of the present application. Therefore, the protection scope of the present application shall be subject to the attached claims.

Claims

1. A service-oriented software process monitoring method based on heterogeneous graph generation transformation rules, characterized in that: The steps include: S1, establish the dependency relationship between classes and methods in the service bytecode file, including class dependency class, method dependency class and method dependency method; S2, based on the established dependencies, use the ASM bytecode manipulation library to build a dependency parsing tool to extract the complete class name of each program class, the method name in each program class, and the dependencies between classes and methods; S3, builds a directory tree based on the hierarchical relationship between classes and methods; S4, constructs a heterogeneous dependency graph based on the two nodes of program class and program method, as well as the dependency relationship between class and method; S5, select the target object through the directory tree, and extract the dependency related to the target object from the dependency heterogeneous graph to form a dependency subgraph; S6, using the Agent program to parse the dependency subgraph to form the instrumentation object rule text, then passing the rule text address to the instrumentation program, and loading the instrumentation program onto the JVM of the service under test; S7, after receiving the address parameter, the instrumentation program parses the rule text into classes and methods with mapping relationships, reloads the successfully matched classes, and makes targeted modifications to the bytecodes of the successfully matched methods; S8, after completing the instrumentation, call the tested service access interface, obtain the program running log after the interface call, and verify the instrumentation effect.

2. The service-oriented software process monitoring method based on heterogeneous graph generation conversion rules according to claim 1 is characterized in that: S2, based on the established dependencies, use the ASM bytecode manipulation library to build a dependency parsing tool. The specific method is as follows: Step 2.1: Use the binary combination of (package name, class name) as the unique identifier for a program class, and the quadruple combination of (package name, class name, method name, method descriptor) as the unique identifier for a program method, where the method descriptor is a string consisting of the method name, parameter type list, and return value type; Step 2.2: Based on the ASM bytecode operation library, deep analysis of program classes is implemented. The ASM bytecode operation library is used to traverse the dependencies between classes. The dependencies between classes include inheritance, implementation, association, and aggregation. At the same time, the dependencies at the program method level are traversed within the class. The dependencies at the program method level include reference, call, and declaration relationships, and the program's unique identifier is used to establish a ternary relationship group of (program identifier A, program identifier B, dependency).

3. The service-oriented software process monitoring method based on heterogeneous graph generation conversion rules according to claim 1 is characterized in that: S3, builds a directory tree based on the hierarchical relationship between classes and methods, where: The hierarchical relationship between classes and methods includes the hierarchy of the packages to which the classes belong in the program and the hierarchy of the methods contained in the classes; The nodes of the directory tree include three levels: packages, classes, and methods. The relationship between the three levels is a parent-child relationship. The class is the child node of the package to which it belongs, and the method in the class is the child node of the class.

4. The service-oriented software process monitoring method based on heterogeneous graph generation conversion rules according to claim 1 is characterized in that: S4, based on the two nodes of program class and program method, as well as the dependency relationship between class and method, construct a dependency heterogeneous graph. The specific method is as follows: Taking the first element of the triple as the starting point, the second element as the end point, and the third element as the connection relationship, a heterogeneous dependency graph consisting of two types of nodes, program class and program method, and multiple connection relationships between them is established. Different dependency relationships between nodes are represented by different types of edges.

5. The service-oriented software process monitoring method based on heterogeneous graph generation conversion rules according to claim 1 is characterized in that: S5, select the target object through the directory tree, and extract the dependency related to the target object from the dependency heterogeneous graph to form a dependency subgraph. The specific method is as follows: Select a program class node or program method node from the directory tree formed by S3, identify the unique identifier of the node, locate the node corresponding to the identifier from the heterogeneous graph network formed by S4, and traverse the graph according to the selected expected dependency relationship through the breadth-first algorithm to obtain the nodes connected to the starting point and form a dependency subgraph.

6. The service-oriented software process monitoring method based on heterogeneous graph generation conversion rules according to claim 1 is characterized in that: S7, after receiving the address parameter, the instrumentation program parses the rule text into classes and methods with mapping relationships, reloads the matched classes, and makes targeted modifications to the bytecodes of the matched methods, where: The parsing rule text is a class and method with a mapping relationship, where the mapping relationship refers to a key-value pair from a class identifier to a method identifier list, and the mapping relationship includes the target program that needs to be reloaded this time; Reloading the matched classes and making targeted modifications to the bytecodes of the matched methods is a process in which, after obtaining the bytecode file of the class corresponding to the key in the mapping relationship, the ASM bytecode operation library is used to perform targeted instrumentation on the program of the method list corresponding to the value, complete the custom modification, and reload the modified bytecode on the JVM.

7. The service-oriented software process monitoring method based on heterogeneous graph generation conversion rules according to claim 1 is characterized in that: S8, after completing the instrumentation, call the tested service access interface, obtain the program running log after the interface call, and verify the instrumentation effect, where: If the accessed interface is the target program interface, the verification operation log should be the modified program execution log. If the accessed interface is not the target program interface, the verification operation log is still the previous program execution log.

8. A service-oriented software process monitoring system based on heterogeneous graph generation transformation rules, characterized in that: Implement the service-oriented software process monitoring method based on heterogeneous graph generation conversion rules as described in any one of claims 1-7 to realize service-oriented software process monitoring based on heterogeneous graph generation conversion rules, divide it into eight modules, and execute s1~s8.

9. A computer device, comprising a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein when the processor executes the computer program, the service-oriented software process monitoring method based on heterogeneous graph generation transformation rules as described in any one of claims 1 to 7 is implemented to realize service-oriented software process monitoring based on heterogeneous graph generation transformation rules.

10. A computer-readable storage medium having a computer program stored thereon, wherein when the computer program is executed by a processor, the service-oriented software process monitoring method based on heterogeneous graph generation transformation rules as described in any one of claims 1 to 7 is implemented to realize service-oriented software process monitoring based on heterogeneous graph generation transformation rules.

Images