A method and system for identifying inter-service call relations between front-end and back-end services based on static analysis

Abstract

The application provides a method and system for identifying the calling relationship between front-end and back-end services based on static analysis, which comprises the following steps: constructing an abstract syntax tree by analyzing the source code of the calling relationship among multi-end services; reading the service name registered by the back-end service, determining the out-going calling trace and the in-coming called trace of the back-end service by traversing the abstract syntax tree, taking the service name as the benchmark point, and constructing the calling link among back-end services according to the out-going calling trace and the in-coming called trace; obtaining the mapping relationship between the back-end service and the back-end interface, and determining the calling trace of the client to the back-end interface by traversing the abstract syntax tree; taking the back-end interface, the back-end service and the client application as nodes, constructing the directed edge among the nodes according to the calling link among back-end services, the mapping relationship between the back-end service and the back-end interface, and the calling trace of the client to the back-end interface, and generating the multi-end calling link graph atlas integrating the calling relationship among multi-end services.

Description

Technical Field

[0001] This invention relates to the field of service governance technology, and in particular to a method and system for identifying call relationships between front-end and back-end services based on static analysis. Background Technology

[0002] As the company's business expands, the number of backend and frontend services is increasing, and the addition of mobile apps has made the entire system architecture increasingly complex. A clear understanding of the dependencies between these services is crucial for the system's stability, maintainability, and security. The backend is the part of the software system or application that runs on the server side, responsible for logic processing, data computation, and resource management. The frontend is the part of the website or application that directly faces the user, running in a browser or displayed to the user as an app.

[0003] Existing technologies use dynamic tracing to obtain call chains, collecting call chain data during service runtime by implanting probes (such as SkyWalking, ZipKin, etc.); or developers or architects manually record and update the call relationships between services within the system through documents, charts, or tables.

[0004] The current dynamic tracing technology has the following characteristics and limitations: 1) It relies on the actual traffic flow of the call path and cannot cover the call paths that are not covered by test cases in the development and testing phase or that are not actually generated by traffic in the production environment, which poses a risk of omission; 2) The data collection by embedding probes at runtime may have a certain impact on performance; 3) It requires the deployment and maintenance of the entire dependent environment system to collect data and can only be used in the deployed environment.

[0005] The current characteristics and limitations of manual document maintenance are: 1) Inefficiency: It is time-consuming and laborious, difficult to keep up with rapid iterations, and easily causes version differences; 2) It is very easy to become outdated: the documents are disconnected from the actual code and have low credibility. Summary of the Invention

[0006] In view of this, embodiments of the present invention provide a method and system for identifying inter-service call relationships based on static analysis, in order to eliminate or improve one or more defects existing in the prior art.

[0007] One aspect of the present invention provides a method for identifying inter-service call relationships based on static analysis. The method includes the following steps: constructing an abstract syntax tree by parsing the source code of inter-service calls; wherein the multiple terminals include backends and clients, and the clients include frontends and / or APP terminals; reading the service names registered by the backend services, determining the outbound call traces and inbound call traces of the backend services by traversing the abstract syntax tree, constructing a call chain between backend services based on the service names as reference points, and constructing a call chain between backend services according to the outbound call traces and inbound call traces; obtaining the mapping relationship between backend services and backend interfaces, and determining the call traces of clients to backend interfaces by traversing the abstract syntax tree; using backend interfaces, backend services, and client applications as nodes, constructing directed edges between nodes according to the call chain between backend services, the mapping relationship between backend services and backend interfaces, and the call traces of clients to backend interfaces, and generating a multi-terminal call chain graph integrating inter-service call relationships.

[0008] In some embodiments of the present invention, before the step of constructing an abstract syntax tree by parsing the source code of inter-service calls between multiple terminals, the method further includes: triggering multi-language static code analysis through CICD technology during the coding, code, or continuous integration phase, and obtaining the source code of inter-service calls between multiple terminals; the step of constructing an abstract syntax tree by parsing the source code of inter-service calls between multiple terminals includes: selecting an appropriate strategy for code scanning analysis based on the different language codes used in the source code of inter-service calls between multiple terminals, and using a parser to convert the source code of inter-service calls between multiple terminals into a tree-structured abstract syntax tree based on the scanning analysis results.

[0009] In some embodiments of the present invention, the step of reading the service name registered by the backend service includes: reading the service name registered by the service in the registry center by analyzing the configuration file of the backend service.

[0010] In some embodiments of the present invention, the outgoing call traces include Feign interface calls and / or HTTP calls, and the incoming call traces include Controller annotations and / or interface definitions; The construction of the backend service call chain based on outbound call traces and inbound call traces includes: matching the outbound call traces and inbound call traces of each service, and connecting the originally isolated call relationships into a line by combining the service names, thus forming a complete backend service call chain.

[0011] In some embodiments of the present invention, the client's call trace to the backend interface includes a mapping from the client service to the backend service and then to the backend interface URL path; the call chain between backend services includes a mapping from the backend caller service to the backend callee service and then to the backend interface URL path; the step of constructing directed edges between nodes based on the backend service call chain, the mapping relationship between backend services and backend interfaces, and the client's call trace to the backend interface, and generating a multi-terminal call chain graph integrating the call relationships between multiple services, includes: for the call relationship between the client and the backend, establishing a call edge from the client application to the backend service and then to the backend interface by analyzing the obtained mapping from the client service to the backend service and then to the backend interface URL path; for the call relationship between backend services, establishing a call edge from service A to service B and then to the backend interface by analyzing the obtained mapping from the backend caller service to the backend callee service and then to the backend interface URL path; wherein, service A and service B refer to two interfaces that have a call and callee relationship.

[0012] In some embodiments of the present invention, the method further includes: generating a complete call relationship graph based on the multi-terminal call link graph, and displaying the generated call relationship graph through a visualization page.

[0013] In some embodiments of the present invention, the method further includes: querying and analyzing through a visual page, wherein the querying and analysis supports some or all of the following functions: querying how many external interfaces a backend service provides; querying how many interfaces of other services a service calls; analyzing which services are affected by a modification of an interface; querying and identifying interfaces that have not been called; and exporting interface documentation or dependency reports.

[0014] Corresponding to the above methods, the present invention also provides a front-end and back-end service call relationship identification system based on static analysis, including a processor, a memory, and a computer program / instructions stored in the memory. The processor is used to execute the computer program / instructions, and when the computer program / instructions are executed, the system implements the steps of any of the methods described in the above embodiments.

[0015] In accordance with the above methods, the present invention also provides a computer-readable storage medium having a computer program / instructions stored thereon, which, when executed by a processor, implements the steps of the method as described in any of the above embodiments.

[0016] Corresponding to the above methods, the present invention also provides a computer program product, including a computer program / instructions that, when executed by a processor, implement the steps of the method as described in any of the above embodiments.

[0017] The method for identifying inter-service call relationships based on static analysis proposed in this invention can associate inter-service call relationships through multi-language static code analysis, thereby constructing a complete multi-terminal call chain graph including front-end, back-end and mobile terminals during coding, code auditing and continuous integration. This helps to integrate scattered call logics scattered across different code repositories and different language platforms, eliminate information asymmetry, and make complex microservice systems transparent and controllable.

[0018] Additional advantages, objects, and features of the invention will be set forth in part in the description which follows, and will also become apparent in part to those skilled in the art upon studying the description, or may be learned by practice of the invention. The objects and other advantages of the invention can be realized and obtained by means of the structures specifically pointed out in the description and drawings.

[0019] Those skilled in the art will understand that the objectives and advantages achievable with the present invention are not limited to those specifically described above, and that the above and other objectives achievable with the present invention will become clearer from the following detailed description. Attached Figure Description

[0020] The accompanying drawings, which are included to provide a further understanding of the invention and form part of this application, are not intended to limit the scope of the invention. In the drawings: Figure 1 This is a flowchart of a method for identifying inter-service call relationships based on static analysis in one embodiment of the present invention.

[0021] Figure 2 This is a flowchart of a method for identifying inter-service call relationships based on static analysis in one embodiment of the present invention. Detailed Implementation

[0022] To make the objectives, technical solutions, and advantages of this invention clearer, the invention will be further described in detail below with reference to the embodiments and accompanying drawings. Here, the illustrative embodiments and descriptions of this invention are used to explain the invention, but are not intended to limit the invention.

[0023] It should also be noted that, in order to avoid obscuring the invention with unnecessary details, only the structures and / or processing steps closely related to the solution according to the invention are shown in the accompanying drawings, while other details that are not closely related to the invention are omitted.

[0024] It should be emphasized that the term "including / comprises" as used herein refers to the presence of a feature, element, step, or component, but does not exclude the presence or addition of one or more other features, elements, steps, or components.

[0025] It should also be noted that, unless otherwise specified, the term "connection" in this article can refer not only to a direct connection, but also to an indirect connection involving an intermediary.

[0026] In the following description, embodiments of the invention will be illustrated with reference to the accompanying drawings. In the drawings, the same reference numerals represent the same or similar parts, or the same or similar steps.

[0027] This invention is based on static analysis, which can perform analysis without deploying or running code and without intruding on the code. Furthermore, through CICD, it can analyze and update the call results of the code in a timely manner. It can automatically and accurately obtain the call chain during the development stage without the system running, covering calls between backend services and calls from the frontend and APP to backend interfaces.

[0028] During the development phase, CICD (Continuous Integration and Continuous Delivery) is used to trigger static code analysis after code is committed to a specific branch. The backend analysis configuration file reads the service name of the backend service in the registry center and scans and matches call traces (such as Feign interface calls and HTTP calls) and called traces (such as Controller annotations and API definitions). The data between various services is matched to form an overall call chain between backend services. The routing files (such as router.js and components) of the frontend and APP code are scanned to read the calls to the backend interfaces and matched with the backend chain to generate an overall call chain graph.

[0029] Figure 1 This is a flowchart of a method for identifying inter-service call relationships based on static analysis in one embodiment of the present invention. The method includes the following steps: Step S110: Construct an abstract syntax tree by parsing the source code of inter-service calls between multiple terminals; wherein, the multiple terminals include backend and client, and the client includes frontend and / or APP terminal.

[0030] Step S120: Read the service name registered by the backend service, determine the outbound call trace and inbound call trace of the backend service by traversing the abstract syntax tree, construct the call chain between backend services based on the service name as the construction benchmark, and construct the call chain between backend services based on the outbound call trace and the inbound call trace.

[0031] Step S130: Obtain the mapping relationship between the backend service and the backend interface, and determine the client's call traces to the backend interface by traversing the abstract syntax tree.

[0032] Among them, the client's call traces to the backend interface can be read by scanning the routing files (such as router.js, components) of the frontend and APP code, and then matched with the backend link to generate an overall call chain graph.

[0033] Step S140: Using backend interfaces, backend services, and client applications as nodes, construct directed edges between nodes based on the call chain between backend services, the mapping relationship between backend services and backend interfaces, and the call traces of clients to backend interfaces, to generate a multi-terminal call chain graph that integrates the call relationships between multiple services.

[0034] The method for identifying inter-service call relationships based on static analysis proposed in this invention can associate inter-service call relationships through multi-language static code analysis. This enables the construction of a complete multi-service call chain graph that includes the front-end, back-end, and mobile terminals during coding, code auditing, and continuous integration. It helps to integrate scattered call logics from different code repositories and different language platforms, eliminate information asymmetry, and make complex microservice systems transparent and controllable.

[0035] In some embodiments of the present invention, before the step of constructing an abstract syntax tree by parsing the source code of inter-service calls between multiple terminals, the method further includes: triggering multi-language static code analysis through CICD technology during the coding, code, or continuous integration phase, and obtaining the source code of inter-service calls between multiple terminals.

[0036] Optionally, the source code for calls between multiple services (i.e., code acquisition) can be obtained by automatically triggering CICD (Continuous Integration and Continuous Delivery) code cloning after code merging via GitLab hooks.

[0037] By employing this invention, multi-language static code analysis can be used to associate cross-project interface definitions and calls. No system deployment is required; analysis can be performed simply by obtaining the code. Code analysis can be conducted during the coding, code review, or continuous integration phases to identify problems in advance and help reduce repair costs.

[0038] In some embodiments of the present invention, the step of constructing an abstract syntax tree by parsing the source code of inter-service calls between multiple terminals includes: selecting an appropriate strategy to perform code scanning analysis based on the different language codes used in the source code of the inter-service calls between multiple terminals, and using a parser to convert the source code of the inter-service calls between multiple terminals into a tree-structured abstract syntax tree based on the scanning analysis results.

[0039] By employing this embodiment of the invention, it is possible to utilize abstract syntax trees to support the analysis of multiple language codes, providing a cross-language technology stack.

[0040] In some embodiments of the present invention, the step of reading the service name registered by the backend service includes: reading the service name registered by the service in the registration center by analyzing the configuration file of the backend service.

[0041] In some embodiments of the present invention, by adopting this embodiment, the "border" of the link graph can be determined by the service name, and the automatic binding of the repository and logical service can be realized. Based on the service name, a complete multi-terminal call link graph can be further constructed.

[0042] In some embodiments of the present invention, the outbound call trace includes Feign interface calls and / or HTTP calls, and the inbound call trace includes Controller annotations and / or interface definitions. The outbound call trace (Egress) refers to the call traces in the scanned code, such as Feign interface declarations and the use of RestTemplate / HTTP clients, to identify "who the service is attempting to call." The inbound call trace: This involves scanning the receive traces in the scanned code, such as Controller annotations and RequestMapping definitions, to identify "which API interfaces" the service exposes for others to access.

[0043] In some embodiments of the present invention, the step of constructing a backend service call link based on outbound call traces and inbound call traces includes: matching the outbound call traces of each service with the inbound call traces of each service, and connecting the originally isolated call relationships into a line by combining the service names, thereby forming a complete backend service call link.

[0044] In a specific embodiment of the present invention, the specific implementation of constructing the backend service call chain based on outbound call traces and inbound call traces can be as follows: cross-compare the data scanned from all services, for example, match the "outbound call" parameter of service A with the "inbound call" interface of service B. Combined with the service name, connect the isolated call relationships into lines, and finally construct a complete backend service call chain graph (Topology).

[0045] Specifically, in another embodiment of the present invention, the definition and calling information of key interfaces are extracted by traversing and analyzing the generated abstract syntax tree.

[0046] For the backend: (1) Identify and extract the annotations defined in the API definition, and obtain information such as the complete interface URL path; (2) Identify the annotations for inter-service calls (such as the @FeignClient annotation) and extract the caller information; (3) Read the configuration file, parse the backend service configuration file to identify the unique service name and establish a correspondence with the provided interface URL; (4) Establish a mapping of caller service -> callee service -> backend interface URL path.

[0047] For clients, this includes front-end and mobile devices.

[0048] Specifically, for the front end: (1) Identify the code that initiates the HTTP call (such as axios.get(), fetch(), etc.), analyze the complete URL of the call and the API service provided by the configuration, and perform pattern matching between the URL called in the front end application code and the API provided by the back end; (2) Establish a mapping of the front end service -> back end service -> back end interface URL path.

[0049] Specifically, for mobile devices: (1) Identify the code that initiates the HTTP call, extract the complete URL of the call and the API service provided by the callee; (2) Establish a mapping of the URL path from mobile device to backend service to backend interface.

[0050] This invention breaks down repository boundaries, connecting numerous independent microservices through logical threads. Based on a "connected-line" link diagram, the system can trace back in reverse, automatically listing all direct and indirect callers. Furthermore, the link diagram can visually identify "zombie interfaces" (i.e., interfaces with inbound definitions but no outbound calls in the entire system), assisting in the removal of redundant code.

[0051] In some embodiments of the present invention, the client's call trace to the backend interface includes a mapping from the client service to the backend service and then to the backend interface URL path, and the call chain between backend services includes a mapping from the backend caller service to the backend callee service and then to the backend interface URL path.

[0052] In some embodiments of the present invention, the step of constructing directed edges between nodes based on the call chain between backend services, the mapping relationship between backend services and backend interfaces, and the client's call traces to the backend interfaces, and generating a multi-terminal call chain graph integrating the call relationships between multiple services, includes: for the call relationship between the client and the backend, establishing a call edge from the client application to the backend service and then to the backend interface by analyzing the mapping from the client service to the backend service and then to the backend interface URL path; for the call relationship between backend services, establishing a call edge from service A to service B and then to the backend interface by analyzing the mapping from the backend caller service to the backend callee service and then to the backend interface URL path; wherein, service A and service B refer to two interfaces that have a call and callee relationship. A service is a container for interfaces, and a service typically contains multiple interfaces.

[0053] Specifically, in another embodiment of the present invention, a global graph database structure is created based on the analyzed mapping relationships. The process includes the following steps for creating the global graph database structure: (1) Node creation: all backend services, frontend applications, mobile applications and all API interfaces analyzed in step 3 are used as nodes; (2) Relationship creation: directed edges are established between nodes based on the mapping relationships analyzed in step 3.

[0054] Specifically, the above relationship creation examples are as follows: 1) For the call relationship between the front-end and back-end, by analyzing the mapping of the front-end service -> back-end service -> back-end interface URL path, a call edge of front-end application -> back-end service -> back-end interface is established; 2) For the call relationship between services, by analyzing the mapping of the back-end caller service -> callee service -> back-end interface URL path, a call edge of service A -> service B -> back-end interface is established; 3) For the call relationship between the mobile terminal and the back-end, by analyzing the mapping of the mobile terminal service -> back-end service -> back-end interface URL path, a call edge of mobile terminal application -> back-end service -> back-end interface is established.

[0055] This invention, by constructing a complete and transparent path from "user clicking a button" to "backend logic execution," clearly demonstrates the entire process impact from the frontend page or upstream service to the backend service and backend port. Furthermore, the "directed edges" in the graph clearly define legitimate access paths, which can be used to efficiently identify security vulnerabilities.

[0056] In some embodiments of the present invention, the method further includes: generating a complete call relationship graph based on the multi-terminal call link graph, and displaying the generated call relationship graph through a visualization page.

[0057] By employing this embodiment of the invention, one can intuitively understand the complete and transparent path from "user clicking a button" to "backend logic execution," which helps reduce the difficulty of understanding the multi-terminal call chain graph during the interaction process.

[0058] In some embodiments of the present invention, the method further includes: querying and analyzing through a visual page, wherein the querying and analysis supports some or all of the following functions: querying how many external interfaces a backend service provides; querying how many interfaces of other services a service calls; analyzing which services are affected by a modification of an interface; querying and identifying interfaces that have not been called; and exporting interface documentation or dependency reports.

[0059] By employing this embodiment of the invention, the access, query, and management of call relationships between services across multiple terminals can be achieved through the various functions provided by the interactive page.

[0060] Furthermore, this solution can be used in the following application scenarios: 1) Impact Analysis: Quickly assess the scope of impact when a service is modified or taken offline.

[0061] 2) Troubleshooting: When a system failure occurs, quickly locate the root cause of the problem and its propagation path.

[0062] 3) Architecture optimization: Identify circular dependencies in the system, filter out bad architectural smells, and refactor.

[0063] 4) Security analysis: Analyze data flow to identify potential risks.

[0064] Figure 2 This is a flowchart of a method for identifying inter-service call relationships based on static analysis in one embodiment of the present invention. This embodiment includes the following steps: First, after code submission, code analysis is initiated by CICD; then, the code is detected using static code analysis technology, and a corresponding analyzer is selected based on the code language; the call relationship mapping is constructed using an AST parser, annotation extractor, and call chain builder to obtain a call chain graph (belonging to graph database structure data) and store it in the graph database.

[0065] In summary, the beneficial technical effects of this solution include: 1) Through multi-language static code analysis, it connects cross-project interface definitions and calls, constructing a complete call relationship graph encompassing front-end, back-end, and mobile terminals during coding, code auditing, and continuous integration. 2) Static code analysis can discover all defined interfaces and callers, providing comprehensive coverage and identifying obscure code that has not been called. 3) It is non-intrusive and incurs no additional performance overhead; static code analysis requires no additional instrumentation, no runtime environment, and consumes no additional resources. 4) It is cross-language and cross-technology stack, supporting the analysis of code in multiple languages. 5) It is automated, inheritable from CI / CD processes for automatic analysis, and automatically updates the call graph as code changes.

[0066] Corresponding to the above method, the present invention also provides a system for identifying the call relationship between front-end and back-end services based on static analysis. The system includes a computer device, which includes a processor and a memory. The memory stores computer instructions, and the processor is used to execute the computer instructions stored in the memory. When the computer instructions are executed by the processor, the system implements the steps of the method described above.

[0067] Corresponding to the methods described above, the present invention also provides a computer-readable storage medium having a computer program / instructions stored thereon, which, when executed by a processor, implements the steps of the method as described in any of the above embodiments. The computer-readable storage medium may be a tangible storage medium, such as random access memory (RAM), main memory, read-only memory (ROM), electrically programmable ROM, electrically erasable programmable ROM, register, floppy disk, hard disk, removable storage disk, CD-ROM, or any other form of storage medium known in the art.

[0068] Corresponding to the above methods, the present invention also provides a computer program product, including a computer program / instructions that, when executed by a processor, implement the steps of the method as described in any of the above embodiments.

[0069] Those skilled in the art will understand that the exemplary components, systems, and methods described in conjunction with the embodiments disclosed herein can be implemented in hardware, software, or a combination of both. Whether implemented in hardware or software depends on the specific application and design constraints of the technical solution. Those skilled in the art can use different methods to implement the described functions for each specific application, but such implementation should not be considered beyond the scope of this invention. When implemented in hardware, it can be, for example, electronic circuits, application-specific integrated circuits (ASICs), appropriate firmware, plug-ins, function cards, etc. When implemented in software, the elements of this invention are programs or code segments used to perform the desired tasks. The programs or code segments can be stored in a machine-readable medium or transmitted over a transmission medium or communication link via data signals carried in a carrier wave.

[0070] It should be clarified that the present invention is not limited to the specific configurations and processes described above and shown in the figures. For the sake of brevity, detailed descriptions of known methods are omitted here. In the above embodiments, several specific steps are described and shown as examples. However, the method process of the present invention is not limited to the specific steps described and shown. Those skilled in the art can make various changes, modifications, and additions, or change the order of steps, after understanding the spirit of the present invention.

[0071] In this invention, features described and / or illustrated for one embodiment may be used in the same or similar manner in one or more other embodiments, and / or combined with or in place of features of other embodiments.

[0072] The above description is merely a preferred embodiment of the present invention and is not intended to limit the invention. For those skilled in the art, various modifications and variations can be made to the embodiments of the present invention. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of the present invention should be included within the scope of protection of the present invention.

Claims

1. A method for identifying inter-service call relationships based on static analysis, characterized in that, include: An abstract syntax tree is constructed by parsing the source code of inter-service calls across multiple terminals; wherein, the multiple terminals include backend and client, and the client includes frontend and / or APP terminal; Read the service name registered by the backend service, determine the outbound call trace and inbound call trace of the backend service by traversing the abstract syntax tree, construct the call chain between backend services based on the service name as the construction benchmark, and construct the call chain between backend services based on the outbound call trace and inbound call trace. Obtain the mapping relationship between backend services and backend interfaces, and determine the client's call traces to the backend interfaces by traversing the abstract syntax tree; By treating backend interfaces, backend services, and client applications as nodes, directed edges are constructed between nodes based on the call chain between backend services, the mapping relationship between backend services and backend interfaces, and the call traces of clients to backend interfaces, thus generating a multi-terminal call chain graph that integrates the call relationships between multiple services.

2. The method according to claim 1, characterized in that, Before the step of constructing an abstract syntax tree by parsing the source code of inter-service calls across multiple terminals, the method further includes: triggering multi-language static code analysis through CICD technology during the coding, code, or continuous integration phase, and obtaining the source code of inter-service calls across multiple terminals; The step of constructing an abstract syntax tree by parsing the source code of inter-service calls between multiple terminals includes: selecting an appropriate strategy to perform code scanning analysis based on the different language codes used in the source code of the inter-service calls between multiple terminals, and using a parser to convert the source code of the inter-service calls between multiple terminals into a tree-structured abstract syntax tree based on the scanning analysis results.

3. The method according to claim 1, characterized in that, The step of reading the service name registered by the backend service includes: reading the service name registered by the service in the registry center by analyzing the configuration file of the backend service.

4. The method according to claim 1, characterized in that, The outgoing call traces include Feign interface calls and / or HTTP calls, and the incoming call traces include Controller annotations and / or interface definitions; The construction of the backend service call chain based on outbound call traces and inbound call traces includes: matching the outbound call traces and inbound call traces of each service, and connecting the originally isolated call relationships into a line by combining the service names, thus forming a complete backend service call chain.

5. The method according to claim 1, characterized in that, The client's call trace to the backend interface includes a mapping from the client service to the backend service and then to the URL path of the backend interface; the call chain between backend services includes a mapping from the backend caller service to the backend callee service and then to the URL path of the backend interface. The step of generating a multi-terminal call chain graph integrating multi-terminal service call relationships by constructing directed edges between nodes based on the call chain between backend services, the mapping relationship between backend services and backend interfaces, and the client's call traces to backend interfaces includes: For the call relationship between the client and the backend, by analyzing the mapping of URL paths from the client service to the backend service and then to the backend interface, a call edge is established from the client application to the backend service and then to the backend interface. For the call relationship between backend services, by analyzing the mapping from the backend caller service to the backend callee service and then to the backend interface URL path, a call edge is established from service A to service B and then to the backend interface; where service A and service B refer to two interfaces that have a caller-callee relationship.

6. The method according to claim 1, characterized in that, The method further includes: generating a complete call relationship graph based on the multi-terminal call chain graph, and displaying the generated call relationship graph through a visualization page.

7. The method according to claim 6, characterized in that, The method further includes: querying and analyzing through a visual page, wherein the querying and analysis supports some or all of the following functions: querying how many external interfaces a backend service provides; querying how many interfaces of other services a service calls; analyzing which services are affected by a modification of an interface; querying and identifying interfaces that have not been called; and exporting interface documentation or dependency reports.

8. A system for identifying inter-service call relationships based on static analysis, comprising a processor, a memory, and a computer program / instructions stored in the memory, characterized in that, The processor is configured to execute the computer program / instructions, and when the computer program / instructions are executed, the system implements the steps of the method as described in any one of claims 1 to 7.

9. A computer-readable storage medium having a computer program / instructions stored thereon, characterized in that, When the computer program / instructions are executed by the processor, they implement the steps of the method as described in any one of claims 1 to 7.

10. A computer program product comprising a computer program / instructions, characterized in that, When the computer program / instructions are executed by the processor, they implement the steps of the method according to any one of claims 1 to 7.

Images