CN108363587B

CN108363587B - Application program operation monitoring method and device, computer equipment and storage medium

Info

Publication number: CN108363587B
Application number: CN201810186263.4A
Authority: CN
Inventors: 段然
Original assignee: Ping An Puhui Enterprise Management Co Ltd
Current assignee: Ping An Puhui Enterprise Management Co Ltd
Priority date: 2018-03-07
Filing date: 2018-03-07
Publication date: 2022-02-01
Anticipated expiration: 2038-03-07
Also published as: CN108363587A

Abstract

The application relates to an application program operation monitoring method and device, computer equipment and a storage medium. The method comprises the following steps: receiving an entry operation of a module code, and detecting whether the entered module code contains a preset type of target statement; if yes, generating a corresponding target label and label description according to the target statement, and adding the target label to the position of the target statement in the module code; traversing the module codes when a compiling instruction is received, and extracting a target label and a corresponding label description; the label description comprises a plurality of page identifications and jump relations among the page identifications; sending the label description to a server, and enabling the server to construct a page jump monitoring graph of an application program corresponding to the module codes by taking the page identifications as nodes and taking jump relations among the page identifications as directed edges according to the received label descriptions corresponding to the module codes respectively; and receiving a page jump monitoring graph returned by the server. By adopting the method, the running condition of the application program can be conveniently, timely and accurately known.

Description

Application program operation monitoring method and device, computer equipment and storage medium

Technical Field

The present application relates to the field of computer technologies, and in particular, to a method and an apparatus for monitoring application program running, a computer device, and a storage medium.

Background

With the development of mobile internet and the strong demand of people for convenient life of internet, more and more APP applications (hereinafter referred to as "APP") are generated. To be able to meet market and user needs continuously, the APP needs to be upgraded continuously to improve its performance, so the same APP may have multiple versions. Each version of APP is typically made up of multiple functional modules, and the different functional modules are completed by different developers. When upgrading the APP, a developer needs to modify one or more functional modules of the APP or add other functional modules. Before upgrading, a developer should make a judgment on a functional module which needs to be modified in the APP, and this depends on understanding of the running condition of the APP, such as a jump relationship among multiple pages in the APP. In the traditional mode, in order to facilitate upgrading of the APP, manual recording is carried out on the APP running condition by each developer in the APP development process, or the APP is tried out after the development is completed to obtain the APP running condition. The manual recording mode is low in efficiency and easy to make mistakes, so that developers can not know the APP operation condition timely and accurately.

Disclosure of Invention

Based on this, it is necessary to provide an APP operation monitoring method, apparatus, computer device and storage medium that can generate a corresponding page jump monitoring graph at any stage of the whole life cycle of the APP at any time, so that developers of each functional module can know the APP operation condition timely and accurately, and then facilitate the APP upgrade.

An application program operation monitoring method, the method comprising: receiving an entry operation of a module code, and detecting whether the entered module code contains a preset type of target statement according to the entry operation; if yes, generating a corresponding target label and label description according to the target statement, and adding the target label to the position of the target statement in the module code; when a compiling instruction is received, traversing the module code according to the compiling instruction, and extracting the target label; the target tag comprises a page jump tag; acquiring a label description corresponding to the page jump label; the label description comprises a plurality of page identifications and jump relations among the page identifications; sending the label description to a server, and enabling the server to construct a page jump monitoring graph of an application program corresponding to the module codes by taking the page identifications as nodes and taking jump relations among the page identifications as directed edges according to the received label descriptions corresponding to the module codes respectively; and receiving a page jump monitoring graph returned by the server.

In one embodiment, the module code comprises page code; the entering operation of the receiving module code comprises the following steps: receiving a design request for a target page, and displaying a design window according to the design request, wherein the design window comprises a page editing area and a plurality of thumbnail icons; capturing the dragging operation of the thumbnail icon, acquiring an element code corresponding to the dragged thumbnail icon, and generating a page element corresponding to the thumbnail icon based on the element code; adding the page elements to corresponding positions of the page editing area according to the dragging operation, and recording the adding sequence of the page elements; when a page saving instruction is received, acquiring a preset template code according to the page saving instruction, and respectively adding element codes corresponding to a plurality of page elements to the template code according to the adding sequence of the plurality of page elements in the page editing area to obtain the target page and the corresponding page codes.

In one embodiment, the target tag further comprises a function call tag; the label description also comprises a plurality of function identifications and calling relations among the function identifications; the method further comprises the following steps: acquiring a label description corresponding to the function calling label; obtaining module version identifications corresponding to the function identifications in the label description respectively; determining version information corresponding to the module code according to the calling relationship among the function identifiers; sending the version information to the server, so that the server respectively corresponds to the version information according to the received module codes, wherein the version information comprises the dependency relationship among the module version identifiers; each module is taken as an independent node, each independent node comprises at least one sub-node, each sub-node corresponds to one module version identifier, and a dependency relationship among the module version identifiers is used for constructing a version dependency monitoring graph of an application program corresponding to a module code for a directed edge; and receiving the version dependence monitoring graph returned by the server.

An APP operation monitoring method, the method comprising: receiving operation information uploaded by a plurality of terminals; the terminal receives an entry operation of a module code, and detects whether the entered module code contains a target statement of a preset type according to the entry operation; if yes, generating a corresponding target label and label description according to the target statement, and adding the target label to the position of the target statement in the module code; when a compiling instruction is received, traversing the module code according to the compiling instruction, and extracting the target label; the target tag comprises a page jump tag; acquiring a label description corresponding to the page jump label; the operational information includes a plurality of the tag descriptions; the label description comprises a plurality of page identifications and jump relations among the page identifications; constructing a page jump monitoring graph of the APP corresponding to the module codes by taking each page identifier as a node and taking the jump relation among the page identifiers as a directed edge; and pushing the page jump monitoring graph to a plurality of terminals.

In one embodiment, the target tag further comprises a function call tag; the label description also comprises a plurality of function identifications and calling relations among the function identifications; the method further comprises the following steps: receiving version information uploaded by a plurality of terminals; the terminal acquires module version identifications corresponding to the function identifications in the label description respectively, and determines version information corresponding to the module codes according to the calling relation among the function identifications; the version information comprises a dependency relationship among a plurality of module version identifications; each module is taken as an independent node, each independent node comprises at least one sub-node, each sub-node corresponds to one module version identification, and a version dependence monitoring graph is constructed for directed edges according to dependence relations among the module version identifications; and pushing the version-dependent monitoring graph to a plurality of terminals.

In one embodiment, the method further comprises: monitoring the version updating dynamic state released by the terminal; the version updating dynamically carries version modification description information; determining an independent node dynamically corresponding to the version updating in the version dependent monitoring graph, searching all directed edges connected with the independent node, and acquiring a label description corresponding to the searched directed edge; comparing the acquired label description with the version modification description information to generate a directed edge modification strategy; and updating the version dependence monitoring graph according to the directed edge modification strategy, and pushing the updated version dependence monitoring graph to a plurality of terminals.

In one embodiment, the pushing the page jump monitoring graph to a plurality of terminals includes: distributing a monitoring graph identifier for the page jump monitoring graph; storing the page jump monitoring graph, and acquiring a storage address link corresponding to the page jump monitoring graph; associating the monitoring graph identification with the storage address link; and generating a two-dimensional code according to the storage address link, and pushing the two-dimensional code to a plurality of terminals.

An application program operation monitoring apparatus, the apparatus comprising: the information marking module is used for receiving the input operation of the module codes and detecting whether the input module codes contain target sentences of preset types or not according to the input operation; if yes, generating a corresponding target label and label description according to the target statement, and adding the target label to the position of the target statement in the module code; the information extraction module is used for traversing the module code according to the compiling instruction and extracting the target label when the compiling instruction is received; the target tag comprises a page jump tag; acquiring a label description corresponding to the page jump label; the label description comprises a plurality of page identifications and jump relations among the page identifications; the operation monitoring module is used for sending the label description to a server, so that the server constructs a page jump monitoring graph of an application program corresponding to the module codes by taking the page identifications as nodes and taking the jump relation among the page identifications as directed edges according to the received label descriptions corresponding to the module codes respectively; and receiving a page jump monitoring graph returned by the server.

A computer device comprising a memory storing a computer program and a processor implementing the steps of any of the methods described above when the computer program is executed.

A computer-readable storage medium, on which a computer program is stored which, when being executed by a processor, carries out the steps of any of the methods described above.

According to the application program operation monitoring method and device, the computer equipment and the storage medium, in the module code compiling process, whether the module code contains the preset type of target statement is detected, and whether the recorded module code contains information capable of representing the corresponding application program operation condition can be judged; when the input module code contains a preset type target statement, generating a corresponding target label and label description according to the target statement, and acquiring detailed information representing the running condition of the application program; by adding the generated target label in the target statement, the information for representing the running condition of the application program can be marked; when the compiling of the module code is completed and the module code is compiled, the target label and the corresponding label description can be extracted through traversing the module code; sending the label description including the multiple page identifications and the jump relation among the page identifications to a server, so that the server can construct a page jump monitoring graph of an application program by taking the page identifications as nodes and the jump relation among the page identifications as directed edges; according to the page jump monitoring graph pushed by the server, developers of all the functional modules can conveniently know the running overview of the application program timely and accurately.

Drawings

FIG. 1 is a diagram illustrating an exemplary scenario for a method for monitoring application program operations;

FIG. 2 is a flowchart illustrating a method for monitoring application program operation according to an embodiment;

FIG. 3 is a diagram illustrating a page jump monitoring graph in an embodiment of a method for monitoring application program operation;

FIG. 4 is a schematic interface diagram of a design window in the application operation monitoring method in one embodiment;

FIG. 5 is a diagram of a version dependency monitor graph in the application run monitoring method in one embodiment;

FIG. 6 is a flowchart illustrating a method for monitoring the operation of an application in accordance with another embodiment;

FIG. 7 is a diagram illustrating an exemplary configuration of an application operation monitoring apparatus;

FIG. 8 is a schematic structural diagram of an application operation monitoring apparatus according to another embodiment;

FIG. 9 is a diagram showing an internal structure of a computer device in one embodiment;

fig. 10 is an internal structural view of a computer device in another embodiment.

Detailed Description

In order to make the objects, technical solutions and advantages of the present application more apparent, the present application is described in further detail below with reference to the accompanying drawings and embodiments. It should be understood that the specific embodiments described herein are merely illustrative of the present application and are not intended to limit the present application.

The application program running monitoring method provided by the application program running monitoring method can be applied to the application environment shown in fig. 1. The plurality of terminals 102 communicate with the server 104 via a network. The terminal 102 may be, but not limited to, various personal computers, notebook computers, smart phones, tablet computers, and portable wearable devices, and the server 104 may be implemented by an independent server or a server cluster formed by a plurality of servers. The application program is generally composed of a plurality of functional modules, and different terminals 102 develop different functional modules. When a developer writes module codes of corresponding functional modules at a terminal, the terminal detects whether the module codes recorded in a preset time length contain target sentences of preset types. When the preset type of target statement exists, the terminal generates a corresponding target label and label description according to the target statement, and adds the target label to the position of the target statement. The target tags include page jump tags. The label description comprises a plurality of page identifications and jump relations among the page identifications. When the module codes are written and a compiling instruction for the module codes is received, the terminal traverses the module codes according to the compiling instruction, extracts all target labels and obtains label descriptions corresponding to the target labels. And the terminal sends all the acquired label descriptions to the server. And the server also receives label description sent by the terminal corresponding to the other functional modules. The server builds a page jump monitoring graph of the application program by taking the page identifications as nodes and the jump relation among the page identifications as directed edges according to the received label descriptions corresponding to the module codes respectively, and pushes the page jump monitoring graph to a plurality of terminals. Because the target sentences capable of reflecting the page jump relation are marked in the module code compiling process and the marks are extracted during compiling, the page jump monitoring graph corresponding to the application program can be obtained, and developers of all functional modules can know the running condition of the application program timely and accurately.

In an embodiment, as shown in fig. 2, an application running monitoring method is provided, which is described by taking the application of the method to the terminal in fig. 1 as an example, and includes the following steps:

step 202, receiving an entry operation of a module code, and detecting whether the entered module code contains a preset type of target statement according to the entry operation.

The application program comprises a plurality of functional modules, each functional module is independently compiled, and each functional module corresponds to one terminal. The terminal is used for developing module codes of corresponding functional modules and extracting operation information, and uploading the extracted operation information to the server. The run information includes a jump relationship between a plurality of pages in the functional module.

When the application program needs to be developed, a developer can write corresponding module codes on the basis of a preset framework at a terminal. The preset frame comprises an information marking component and an information extracting component. The information marking component is used for detecting whether the input module codes contain the target sentences of the preset types or not and marking the target sentences when the target sentences are contained. The information extraction component is used for extracting the marks in the module codes to obtain the running information corresponding to the module codes. The preset type target statement may be a page generation statement, a page state change statement, a page jump statement, or the like.

The data items to be extracted in the module code can be set by configuring the preset type of target statements. It should be noted that the data items extracted in this embodiment include information about page generation, state change, and jumping, and developers may extend the data items to be extracted at any time in a custom manner.

And 204, if the target statement exists, generating a corresponding target label and label description according to the target statement, and adding the target label to the position of the target statement in the module code.

When a developer inputs a module code into a terminal, the terminal detects whether the input module code contains a preset type of target statement or not by using a preset frame. And when the preset type of target statement is detected, the terminal generates a corresponding target label and label description according to the target statement. The target tags include page jump tags. According to different types of target statements, page jump tags can be divided into creation tags, state tags, jump tags and the like. The tag description corresponding to the created tag includes one or more page identifications. Each page may have multiple display states such as a default state, a pop-up advertisement state, etc. The label description corresponding to the state label comprises a page identifier, a first display state, a second display state and a state change condition. The label description corresponding to the jump label comprises a plurality of page identifications, jump relations among the page identifications, jump conditions and the like. The target tags corresponding to different target sentences of the same type can be distinguished by numbers and the like.

And adding the terminal target label to the position of the corresponding target sentence to mark the target sentence. Specifically, the terminal may generate a creation tag according to the page generation statement, such as "@ creation" and the like. The terminal registers a page identifier for the created page, generates a corresponding label description according to the page identifier, such as 'create page A', and inserts the created label before or after the page generation statement. The terminal can generate a state tag according to the page state change statement, such as state change # #andthe like; the corresponding tag description may be that "when a click operation on a preset button in the page is received, the page is converted from the pop-up advertisement state to the default state", and the creation tag is inserted before or after the page state change statement. The terminal can generate a jump tag according to the page jump statement, such as "jump", and the corresponding tag description can be "jump from the page a to the page B when a click operation on a preset link in the page is received", and insert the jump tag before or after the page jump statement.

The terminal can distinguish different display states of the same page through the page identification and the state identification. The status flag may be denoted by i. Wherein i is more than or equal to 1 and less than or equal to n, i is an integer, and n is the number of types of display states of one page. Thus, a page state change may also be understood as a page jump. For example, the tag description corresponding to the state tag may be "when a click operation on a preset button in the page is received, the page a1 jumps to the page a 2", so that the tag description corresponding to the state tag further includes a state identifier corresponding to the page.

When the target statement of the preset type in the module code is modified, the terminal modifies the corresponding target label and label description by using the preset frame. Because the target tag is inserted into the module code, when the module code needs to be modified subsequently, the terminal can not detect the sentence which has the target tag and is not modified any more, so that the occupation of terminal resources can be reduced, the detection efficiency of the preset type target sentence can be improved, and the extraction efficiency of the operation information is improved.

And the terminal associates the label description with the corresponding created label and stores the associated label description to a specified directory. And the terminal detects whether the input module codes contain the target sentences of the preset type or not at intervals of preset time by using a preset frame according to the above, and marks the target sentences when the target sentences are contained.

Step 206, traversing the module code according to the compiling instruction and extracting a target label when the compiling instruction is received; the target tag comprises a page jump tag; acquiring a label description corresponding to a page jump label; the label description comprises a plurality of page identifications and jump relations among the page identifications.

When the module code is compiled and needs to be compiled, the terminal acquires a compiling instruction of a developer, and compiles the module code by using a preset frame according to the compiling instruction. Specifically, when a compiling instruction for the module code is received, the terminal generates a callback instruction for the information extraction component in the preset frame. And the information extraction component traverses the module code according to the callback instruction, extracts all target tags in the module code, and acquires the tag description corresponding to each target tag in the specified directory. And the terminal also packs, compresses or obfuscates the module codes according to the compiling instruction.

And step 208, sending the label descriptions to a server, so that the server constructs a page jump monitoring graph of the application program corresponding to the module codes by taking the page identifications as nodes and taking the jump relation among the page identifications as directed edges according to the received label descriptions corresponding to the plurality of module codes respectively.

And the terminal sends the acquired label description as the running information of the module code to the server. And the server also receives label description sent by the terminal corresponding to the other functional modules. And the server describes and constructs a page jump monitoring graph of the application program for the received label corresponding to the plurality of module codes respectively. Specifically, as shown in fig. 3, the server constructs a corresponding node for each page identifier and state identifier, generates a directed edge according to a jump relationship between the page identifiers, where the directed edge connects two page identifiers having a jump relationship, and an arrow of the directed edge points to a target jumping party, and if "jump from page a to page B" in tag description, the arrow of the directed edge points to page B. The two nodes with the jump relation can jump in one direction or in two directions. In another embodiment, the server associates the generated directed edge with the corresponding label description, thereby completing the construction of the page jump monitoring graph. It should be noted that the jump relationship between the page identifiers is not limited to that shown in the diagram, and all reasonable jump relationships can be displayed in the form of a page jump monitoring diagram in the above manner.

In another embodiment, when the terminal cannot construct the page jump monitoring graph through the server, the terminal may locally construct the page jump monitoring graph corresponding to the module code in the above manner in an offline state. In yet another embodiment, the preset frame presets a style file. The style file is a template picture file of the page jump monitoring picture. And rendering the style file by using the extracted label descriptions under the offline state of the terminal to obtain a page jump monitoring graph corresponding to the module codes. Under an off-line state, the construction of the page jump monitoring graph can be realized through a preset frame, and developers can conveniently know the development details of the current module codes in time.

It should be noted that the application running monitoring method provided by this embodiment is not only applicable to the application in development, but also applicable to the application that has already been developed. For the application program which is already developed, the corresponding page jump monitoring graph can be obtained through recompilation.

And step 210, receiving a page jump monitoring graph returned by the server.

The server pushes the page jump monitoring graph to the terminal corresponding to each function module of the application program, so that developers of each function module can know the running overview of the application program timely and accurately.

In the embodiment, in the process of writing the module codes, whether the module codes contain the preset type of target statements or not is detected, and whether the recorded module codes contain information capable of representing the running condition of the corresponding application program or not can be judged; when the input module code contains a preset type target statement, generating a corresponding target label and label description according to the target statement, and acquiring detailed information representing the running condition of the application program; by adding the generated target label in the target statement, the information for representing the running condition of the application program can be marked; when the compiling of the module code is completed and the module code is compiled, the target label and the corresponding label description can be extracted through traversing the module code; sending the label description including the multiple page identifications and the jump relation between the page identifications to a server, so that the server can use the page identifications as nodes and use the jump relation between the page identifications as directed edges to construct a page jump monitoring graph of an application program; according to the page jump monitoring graph pushed by the server, developers of all the functional modules can conveniently know the running overview of the application program timely and accurately.

In one embodiment, the module code includes page code; the entering operation of the received module code comprises the following steps: receiving a design request for a target page, and displaying a design window according to the design request, wherein the design window comprises a page editing area and a plurality of thumbnail icons; capturing the dragging operation of the thumbnail icon, acquiring an element code corresponding to the dragged thumbnail icon, and generating a page element corresponding to the thumbnail icon based on the element code; adding the page elements to corresponding positions of the page editing area according to the dragging operation, and recording the adding sequence of the page elements; when a page saving instruction is received, acquiring a preset template code according to the page saving instruction, and respectively adding element codes corresponding to a plurality of page elements to the template code according to the adding sequence of the plurality of page elements in the page editing area to obtain a target page and corresponding page codes.

And a page design tool for generating a target page and a corresponding page code is operated on the terminal. The page design tool can be interface-oriented programming so as to support any technical framework for realizing the corresponding interface method, such as the UI frameworks of React, Vue, Angular and the like, and improve the expansibility of the page design tool. Before page development is carried out, a developer can carry out initialization configuration on a technical framework which is required to be adopted specifically.

A tool library is deployed in the page design tool. A plurality of thumbnail icons and corresponding element codes are preset in the tool library. The thumbnail icons and the corresponding element codes can be extracted from program codes of a plurality of historical APPs by developers and are configured in a page design tool in advance. The thumbnail icon may be a thumbnail corresponding to a page element that may be used in the page design process, such as a button, a text box, a picture, or a table. It should be noted that the thumbnail icon is used for facilitating the search and preview of the developer, and is not editable; and the page element is a control with the same or similar shape as the thumbnail icon and can be edited. The element code may be the basic logic code for displaying the page element to which the thumbnail icon corresponds. The element codes corresponding to different thumbnail icons may be different. The element code comprises various attribute parameters, such as font, color, size or alignment mode, and the corresponding view effect can be realized. It will be readily appreciated that a variety of different view effects are possible for the same page element, and thus a variety of corresponding element codes may be provided for the same thumbnail icon. The parameter value of the attribute parameter in each element code may be a preset default value.

When a certain target page needs to be developed, a developer can start a page design tool at a terminal to design the page. And the terminal receives a design request for a target page triggered by a developer through a starting operation and displays a design window according to the design request. As shown in fig. 4, the design window includes a function menu area, an element preview area, a page edit area, and the like. The function menu region includes a plurality of function buttons such as a save button, a set button, and the like. The page editing area is used for accommodating a plurality of page elements. The element preview area includes a plurality of thumbnail icons. In order to facilitate searching for the thumbnail icons, a plurality of thumbnail icons can be classified, such as media-type thumbnail icons, prompt-type thumbnail icons, edit-type thumbnail icons, and the like. In order to facilitate more accurate positioning of the thumbnail icons, a corresponding icon identifier, such as an icon name, may be set for each thumbnail icon. The thumbnail icon is convenient for developers to visually preview, so that the thumbnail icon is convenient to search, and the page development efficiency is improved.

The terminal captures the dragging operation of the thumbnail icon, obtains an element code corresponding to the dragged thumbnail icon, and generates a page element corresponding to the thumbnail icon based on the element code. Specifically, after finding a needed thumbnail icon, a developer may select the thumbnail icon by dragging or double-clicking, and add a page element corresponding to the thumbnail icon to the page editing area. Specifically, when a click operation of a mouse on a certain thumbnail icon or a touch operation of a finger on the certain thumbnail icon is captured, the terminal detects whether the thumbnail icon corresponds to multiple sub thumbnail icons realizing different view effects. As shown in fig. 4, when there are a plurality of sub-thumbnail icons for implementing different view effects for the selected thumbnail icon, the terminal displays a sub-icon display frame at the position of the selected thumbnail icon. The sub-icon display frame comprises a plurality of sub-thumbnail icons and corresponding icon identifications. The developer can further select the sub thumbnail icons closer to the requirements of the developer from the sub icon display frame, so that the developer can achieve the expected view effect on the selected sub thumbnail icons without modification or with less modification, and the page development efficiency can be further improved.

And the terminal adds the page elements to corresponding positions of the page editing area according to the dragging operation and records the adding sequence of the page elements. Specifically, the terminal acquires the corresponding element code according to the selected thumbnail icon or the sub-thumbnail icon, and generates the corresponding page element based on the acquired element code. And the terminal adds the generated page elements to corresponding positions of the page editing area according to the dragging operation. It is easy to understand that when the developer selects the thumbnail icon by means of double-click or the like, the terminal may add the generated page element to the default position of the page editing area according to the click operation, and then move the generated page element to the corresponding position of the page editing area according to the further drag operation of the developer. The developer can add a plurality of page elements to the page editing area in sequence according to the above manner, and record the adding sequence of each page element.

The page design tool presets a plurality of element types and layer relations among the element types. Each element type includes a plurality of page elements. The layer relation refers to the upper and lower position relation of two successively added page elements in the page editing area. The terminal determines the element type of each page element in the page editing area according to multiple preset element types; and determining the layer relation between each page element and other page elements in the page editing area according to the preset layer relation among multiple element types.

After the addition of all the required page elements is completed, the target page is designed, and developers can store the target page by clicking a storage button in the design window. The method comprises the steps that after a page saving instruction corresponding to a saving button clicking operation is received by a terminal, a preset template code is obtained according to the page saving instruction, element codes corresponding to corresponding page elements are changed according to the layer relation between each page element and other page elements in a page editing area, and the changed element codes corresponding to a plurality of page elements are added to the template code respectively. The template code is the basic logic code for displaying a complete target page. In other words, the module code includes the same partial code, such as page definition statements, used in different page codes. The module codes adopted for designing different target pages can be the same or different.

And the terminal marks the module codes added with the plurality of element codes as page codes corresponding to the target page, and developers optimize the page codes and add corresponding logic codes to obtain the module codes. In other words, the module code includes page code and logic code. A developer only needs to develop the page on the basis of the page code automatically generated by the page design tool, and the page development efficiency is improved.

In this embodiment, because the page elements are dynamically generated based on the element codes, and the element codes have preset view logic, developers can splice to obtain a required target page by dragging the page elements to the page editing area boldly, so that the page development efficiency can be improved. The development of page codes is completed while page design is carried out, the trouble of cutting pictures and manually programming by developers is avoided, the page development efficiency can be improved, and the application program development efficiency is further improved.

In one embodiment, the target tag further comprises a function call tag; the label description also comprises a plurality of function identifications and calling relations among the function identifications; the method further comprises the following steps: acquiring a label description corresponding to the function calling label; acquiring module version identifications corresponding to a plurality of function identifications in the label description; determining version information corresponding to the module code according to the calling relationship among the function identifiers; sending the version information to a server, so that the server respectively corresponds to the version information according to the received module codes, wherein the version information comprises the dependency relationship among the module version identifications; each module is taken as an independent node, each independent node comprises at least one sub-node, each sub-node corresponds to one module version identification, and a dependency relationship between the module version identifications is used for constructing a version dependency monitoring graph of an application program corresponding to the module code for the directed edge; and receiving the version dependence monitoring graph returned by the server.

A dependency relationship may exist between different functional modules of an application, and if the implementation of the function of module X requires the invocation of an interface of module Y, module X depends on module Y. When the functional module is upgraded, the active or passive related module code is likely to be changed, and the associated other functional modules are disabled in function, that is, the interface is not matched, the function is not matched, and the like.

Each module code may have multiple versions, and in order to distinguish different fast codes of different versions, the corresponding module code is identified by a module version identification. The module version identifier includes a module identifier and a version number, such as X1.0, where X represents a module X and 1.0 represents a version number. The dependency relationship between different functional modules is a call relationship between different functional modules, such as library call, configuration call, interface call, and the like. If X1.0 invokes one or more functional interfaces (e.g., payment interfaces) of Y1.0 in implementing the corresponding function of the functional module, then X1.0 relies on Y1.0.

The preset type target statements further comprise function definition statements, function calling statements and the like. Generating the target tag from the target statement further includes function call tagging. According to different types of target statements, function call tags can be divided into definition tags, call tags and the like. In the module code entering process, the terminal adds a definition tag and/or a calling tag in the module code by using a preset frame according to the mode, and stores the tag description corresponding to the definition tag and the calling tag to the specified directory. And when the compiling instruction is received, the terminal extracts the function calling label from the module code and acquires the corresponding label description in the specified directory. The tag description corresponding to the definition tag includes one or more function identifications. The label description corresponding to the calling label includes a plurality of function identifications and calling relations among the function identifications, such as 'function M calls function N'.

And the terminal acquires the module version identification corresponding to each function identification in the label description. The module version identifier corresponding to the function identifier refers to a module version identifier corresponding to a module code for defining a function corresponding to the function identifier for the first time, and if the function M is defined in the module code X of the first version for the first time, the module version identifier corresponding to the function M is X1.1; the function N is defined in the module code Y of the first version for the first time, and the module version identifier corresponding to the function N is Y2.0. Each definition tag has a corresponding module version identification, i.e., the module version identification of the module code in which the definition tag is located. The module version identifier corresponding to the function identifier may be obtained according to a definition tag corresponding to the tag description to which the function identifier belongs.

And the terminal converts the label description comprising the calling relation among the function identifications according to the module version identification corresponding to the function identification. The converted tag description includes a dependency relationship between a plurality of module version identifications, such as "module version Y2.0 calls module version X1.1". And the terminal sends the dependency relationship among the module version identifications as version information corresponding to the module codes to the server.

And the server constructs a version dependence monitoring graph according to the received version information of each functional module. Specifically, as shown in fig. 5, the server constructs a corresponding independent node for each functional module, and constructs child nodes for a plurality of module versions under the functional module, such as X1.0, X1.1, and X1.2. The server generates a directed edge according to the dependency relationship among the module versions, the directed edge connects the two mutually dependent module versions, and an arrow of the directed edge points to an active dependency party, if the module version Y2.0 calls X1.1, Y2.0 is the active dependency party, and X1.1 is a passive dependency party.

In another embodiment, the tag description further includes location information of the dependent code in the corresponding module code, and the like. Dependent code refers to the module code that appears in the active relying party, but defines the interface, configuration information, tool libraries, etc. implemented in the passive relying party. For example, when the function module Y2.0 calls one or more function interfaces (e.g. payment interfaces) of the function module X1.1 when implementing the corresponding functions of the module, the function module Y2.0 depends on the function module X1.1, and the called interface is an associated interface between two function modules. And the server makes the generated directed edge associated with the corresponding label description, thereby completing the construction of the version dependent monitoring graph. It should be noted that the dependency relationship between module versions is not limited to that shown in fig. 5, and all reasonable dependency relationships can be displayed in the form of a version dependency monitoring graph in the above manner.

In this embodiment, in the process of developing the functional module, the terminal responsible for module development, operation and maintenance and upgrade marks the statements representing the dependency relationship with other functional modules, and extracts the statements during compiling, so as to extract the information representing the running condition of the application program scattered in the module code. Each terminal uploads the version information of the managed functional module, namely the dependency relationship among the version identifiers of the modules. The server collects the information uploaded by the terminal to construct a version dependence monitoring graph, displays the dependence relationship among the versions of the modules in a graphic visualization mode, and facilitates developers of the functional modules to know the running overview of the application program timely and accurately, thereby facilitating the operation, maintenance and upgrading of the application program.

In one embodiment, as shown in fig. 6, there is provided an application program operation monitoring method, which is described by taking the application of the method to the server in fig. 1 as an example, and includes the following steps:

step 602, receiving operation information uploaded by a plurality of terminals; the terminal receives the input operation of the module codes and detects whether the input module codes contain target sentences of preset types or not according to the input operation; if yes, generating a corresponding target label and label description according to the target statement, and adding the target label to the position of the target statement in the module code; when a compiling instruction is received, traversing the module code according to the compiling instruction, and extracting a target label; the target tag comprises a page jump tag; acquiring a label description corresponding to a page jump label; the operation information comprises a plurality of label descriptions; the label description comprises a plurality of page identifications and jump relations among the page identifications.

And step 604, constructing a page jump monitoring graph of the APP corresponding to the module codes by taking each page identifier as a node and taking the jump relation among the page identifiers as a directed edge.

Step 606, pushing the page jump monitoring graph to a plurality of terminals.

In one embodiment, the target tag further comprises a function call tag; the label description also comprises a plurality of function identifications and calling relations among the function identifications; the method further comprises the following steps: receiving version information uploaded by a plurality of terminals; the terminal acquires module version identifications corresponding to a plurality of function identifications in the label description respectively, and determines version information corresponding to module codes according to the calling relation among the function identifications; the version information comprises a dependency relationship among a plurality of module version identifications; each module is taken as an independent node, each independent node comprises at least one sub-node, each sub-node corresponds to one module version identification, and a dependency relationship among the module version identifications is used for constructing a version dependency monitoring graph for the directed edges; and pushing the version-dependent monitoring graph to a plurality of terminals.

In one embodiment, the method further comprises: monitoring version updating dynamic state released by a terminal; the version updating dynamic carries version modification description information; determining an independent node dynamically corresponding to version updating in the version dependence monitoring graph, searching all directed edges connected with the independent node, and acquiring label description corresponding to the searched directed edges; comparing the obtained label description with the version modification description information to generate a directed edge modification strategy; and updating the version dependence monitoring graph according to the directed edge modification strategy, and pushing the updated version dependence monitoring graph to a plurality of terminals.

And the server monitors the version updating dynamic state of each module code and dynamically acquires the version modification description information according to the version updating. Specifically, the server grasps the version modification document updated by the terminal at regular time according to the set path, and analyzes the document to acquire the version modification description information. Or the server acquires the version update dynamic state uploaded by the terminal so as to acquire the corresponding version modification description information.

The version modification description information includes a description of a modification to the historical version module code and/or a description of a modification to the new version module code. The modified description of the historical version module code comprises modified module version identification, specific content and the like. The modification description of the new version module code comprises modification content, added functions, function description and the like of the historical version module code, wherein the modification content is compared with the new version module code which is closest to the new version module code.

And the server determines an independent node dynamically corresponding to the version update in the version dependent monitoring graph, searches all directed edges connected with the independent node and acquires the label description associated with the searched directed edges. For example, assume that terminal a issues a version update dynamic regarding function module X, such as a modification to module version X1.1 or a trial release of upgraded version X1.2. According to the acquired version updating dynamics, the function module located by the server is module X, and it can be known from fig. 5 that there are three directed edges connected to the independent node of module X, including a directed edge whose Y2.0 depends on X1.1, and directed edges whose Z1.0 and Z1.2 depend on X1.1. And confirming that the functional module having a linkage relation with the version upgrade comprises a module Y and a module Z according to the connected directed edges.

And the server compares the version modification description information with the label description associated with each directed edge connected with the independent node in sequence to generate a directed edge modification strategy, wherein the directed edge modification strategy comprises the steps of modifying the existing directed edge and/or generating a new directed edge.

To determine whether the modifications involved in the modification description have modified the original dependent portion. If yes, the server deletes the existing directed edge and/or modifies the label description corresponding to the existing directed edge according to the comparison result. For example, the called interface is an association interface between two functional modules having a dependency relationship; and if the call to the associated interface is modified and deleted, deleting the corresponding directed edge and the corresponding label description. If, as shown in fig. 5, Y2.0 is modified, and the modified Y2.0 removes the call to the original associated interface of the module X1.1, the directed edge between Y2.0 and X1.1 is deleted, and the label description corresponding to the directed edge is deleted at the same time.

After the existing directed edge is modified, it needs to be determined whether the modification causes instability of the dependency relationship. If the modified module version relates to modification of the dependent part, the dependency corresponding to the corresponding directed edge is unstable, and if the passive relying party modifies the call address of the associated interface, the function of the active relying party related to the dependent part cannot be realized. And sending reminding information to the corresponding terminal, wherein the reminding information contains the modified description information modified at this time, the related directed edges, the corresponding label description and other information.

In another embodiment, unstable directed edges due to modification may also be identified, such as modifying the color of the associated directed edge or bolding the directed edge. For example, terminal a modifies module X1.1 and modifies the associated interface X called by module Z1.0. The modification is recorded in the version modification description information, when the version modification description information is compared with the label description of the directed edge between X1.1 and Z1.0, the occurrence of the dependent partial modification is confirmed, the directed edge between X1.1 and Z1.0 is identified, and the corresponding modification description is associated with the directed edge. When the terminal C receives the updated version dependence monitoring graph, the problem of interface mismatching caused by the modification can be known by clicking the directed edge of the identifier, and corresponding processing is carried out in time. If the terminal issues an abandon instruction for the module Z1.0, the child node corresponding to the module version is deleted in the version-dependent monitoring graph according to the abandon instruction, and then the unstable directed edge is deleted. Similarly, the server can further judge whether the abandon modification affects other modules, and make a corresponding modification strategy through information comparison until the whole version dependence monitoring graph reaches a stable state. The corresponding terminal A can also know the problem of interface mismatching caused by the dependency relationship in time for the modification so as to further check the modification.

And the server updates the version dependence monitoring graph according to the directed edge modification strategy and pushes the updated version dependence monitoring graph to the terminal related to the current modification. The related terminals include a terminal with a dynamic release version update and other terminals related to the current modification.

In this embodiment, the change of the dependency relationship caused by the current version upgrade or the generation of a new directed edge is determined according to the monitored dynamic version update and the related dependency information in the version dependency monitor graph, so as to continuously update the visual version dependency monitor graph, and push the updated version dependency monitor graph to the terminal associated with the current update, so that the corresponding terminal can timely and clearly know the version change condition of the associated functional module, and make corresponding confirmation and processing in the first time. The automatic management of the dependency relationship among the functional modules is realized in the embodiment, the management efficiency is higher, the linkage real-time performance among the modules is stronger, and the mismatching hidden danger caused by the dependency relationship can be reduced to a great extent.

In one embodiment, pushing the page jump monitoring graph to a plurality of terminals comprises: distributing a monitoring graph identifier for the page jump monitoring graph; storing the page jump monitoring graph, and acquiring a storage address link corresponding to the page jump monitoring graph; associating the monitoring graph identifier with the storage address link; and generating a two-dimensional code according to the storage address link, and pushing the two-dimensional code to a plurality of terminals.

The monitoring graph identifier is information capable of uniquely identifying a page jump monitoring graph, such as a monitoring graph name, a monitoring graph number and the like. The server associates the page jump monitoring graph with the corresponding monitoring graph identifier, stores the associated page jump monitoring graph, acquires the corresponding storage address link, and associates the monitoring graph identifier with the corresponding storage address link. In order that developers of each functional module can quickly obtain the page jump monitoring graph, the server generates two-dimensional codes according to the storage address links corresponding to the page jump monitoring graph, and then pushes the two-dimensional codes to each terminal, so that the corresponding page jump monitoring graph can be obtained by scanning the two-dimensional codes subsequently.

In the embodiment, after the page jump monitoring graph is stored, the two-dimensional code is generated according to the storage address link and is pushed to each terminal, so that developers can conveniently and quickly obtain the page jump monitoring graph by scanning the two-dimensional code.

It should be understood that although the steps in the flowcharts of fig. 2 and 6 are shown in order as indicated by the arrows, the steps are not necessarily performed in order as indicated by the arrows. The steps are not performed in the exact order shown and described, and may be performed in other orders, unless explicitly stated otherwise. Moreover, at least some of the steps in fig. 2 and 6 may include multiple sub-steps or multiple stages that are not necessarily performed at the same time, but may be performed at different times, and the order of performing the sub-steps or stages is not necessarily sequential, but may be performed alternately or alternately with other steps or at least some of the sub-steps or stages of other steps.

In one embodiment, as shown in fig. 7, there is provided an application program operation monitoring apparatus including: an information marking module 702, an information extraction module 704, and an operation monitoring module 706, wherein:

the information marking module 702 is configured to receive an entry operation of a module code, and detect whether the entered module code includes a preset type of target statement according to the entry operation; and if so, generating a corresponding target label and label description according to the target statement, and adding the target label to the position of the target statement in the module code.

The information extraction module 704 is used for traversing module codes according to the compiling instruction and extracting a target label when the compiling instruction is received; the target tag comprises a page jump tag; acquiring a label description corresponding to a page jump label; the label description comprises a plurality of page identifications and jump relations among the page identifications.

The operation monitoring module 706 is configured to send the tag descriptions to the server, so that the server constructs a page jump monitoring graph of the application program corresponding to the module codes by using the page identifiers as nodes and using the jump relationships between the page identifiers as directed edges according to the received tag descriptions corresponding to the plurality of module codes respectively; and receiving a page jump monitoring graph returned by the server.

In one embodiment, the module code includes page code; the information marking module 702 includes a page design module 7022, configured to receive a design request for a target page, and display a design window according to the design request, where the design window includes a page editing area and a plurality of thumbnail icons; capturing the dragging operation of the thumbnail icon, acquiring an element code corresponding to the dragged thumbnail icon, and generating a page element corresponding to the thumbnail icon based on the element code; adding the page elements to corresponding positions of the page editing area according to the dragging operation, and recording the adding sequence of the page elements; when a page saving instruction is received, acquiring a preset template code according to the page saving instruction, and respectively adding element codes corresponding to a plurality of page elements to the template code according to the adding sequence of the plurality of page elements in the page editing area to obtain a target page and corresponding page codes

In one embodiment, the target tag further comprises a function call tag; the label description also comprises a plurality of function identifications and calling relations among the function identifications; the operation monitoring module 706 is further configured to obtain a tag description corresponding to the function call tag; acquiring module version identifications corresponding to a plurality of function identifications in the label description; determining version information corresponding to the module code according to the calling relationship among the function identifiers; sending the version information to a server, so that the server respectively corresponds to the version information according to the received module codes, wherein the version information comprises the dependency relationship among the module version identifications; each module is taken as an independent node, each independent node comprises at least one sub-node, each sub-node corresponds to one module version identification, and a dependency relationship between the module version identifications is used for constructing a version dependency monitoring graph of an application program corresponding to the module code for the directed edge; and receiving the version dependence monitoring graph returned by the server.

In one embodiment, as shown in fig. 8, there is provided an application program operation monitoring apparatus including: an information marking module 802, an information extraction module 804, and an operation monitoring module 806, wherein:

an operation information obtaining module 802, configured to receive operation information uploaded by multiple terminals; the terminal receives the input operation of the module codes and detects whether the input module codes contain target sentences of preset types or not according to the input operation; if yes, generating a corresponding target label and label description according to the target statement, and adding the target label to the position of the target statement in the module code; when a compiling instruction is received, traversing the module code according to the compiling instruction, and extracting a target label; the target tag comprises a page jump tag; acquiring a label description corresponding to a page jump label; the operation information comprises a plurality of label descriptions; the label description comprises a plurality of page identifications and jump relations among the page identifications.

And the monitoring graph building module 804 is used for building a page jump monitoring graph of the APP corresponding to the module code by taking each page identifier as a node and taking the jump relation between the page identifiers as a directed edge.

And a monitoring graph pushing module 806, configured to push the page jump monitoring graph to multiple terminals.

In one embodiment, the target tag further comprises a function call tag; the label description also comprises a plurality of function identifications and calling relations among the function identifications; the monitoring graph building module 804 is further configured to receive version information uploaded by a plurality of terminals; the terminal acquires module version identifications corresponding to a plurality of function identifications in the label description respectively, and determines version information corresponding to module codes according to the calling relation among the function identifications; the version information comprises a dependency relationship among a plurality of module version identifications; each module is taken as an independent node, each independent node comprises at least one sub-node, each sub-node corresponds to one module version identification, and a dependency relationship among the module version identifications is used for constructing a version dependency monitoring graph for the directed edges; and pushing the version-dependent monitoring graph to a plurality of terminals.

In one embodiment, the apparatus further includes a monitoring graph updating module 808, configured to monitor a version update dynamic state issued by the terminal; the version updating dynamic carries version modification description information; determining an independent node dynamically corresponding to version updating in the version dependence monitoring graph, searching all directed edges connected with the independent node, and acquiring label description corresponding to the searched directed edges; comparing the obtained label description with the version modification description information to generate a directed edge modification strategy; and updating the version dependence monitoring graph according to the directed edge modification strategy, and pushing the updated version dependence monitoring graph to a plurality of terminals.

In one embodiment, the monitoring graph pushing module 806 is further configured to allocate a monitoring graph identifier for the page jump monitoring graph; storing the page jump monitoring graph, and acquiring a storage address link corresponding to the page jump monitoring graph; associating the monitoring graph identifier with the storage address link; and generating a two-dimensional code according to the storage address link, and pushing the two-dimensional code to a plurality of terminals.

For specific limitations of the application program operation monitoring device, reference may be made to the above limitations of the application program operation monitoring method, which are not described herein again. The modules in the application program operation monitoring device can be wholly or partially realized by software, hardware and a combination thereof. The modules can be embedded in a hardware form or independent from a processor in the computer device, and can also be stored in a memory in the computer device in a software form, so that the processor can call and execute operations corresponding to the modules.

In one embodiment, a computer device is provided, which may be a terminal, and its internal structure diagram may be as shown in fig. 9. The computer device includes a processor, a memory, a network interface, a display screen, and an input device connected by a system bus. Wherein the processor of the computer device is configured to provide computing and control capabilities. The memory of the computer device comprises a nonvolatile storage medium and an internal memory. The non-volatile storage medium stores an operating system and a computer program. The internal memory provides an environment for the operation of an operating system and computer programs in the non-volatile storage medium. The network interface of the computer device is used for communicating with an external terminal through a network connection. The computer program is executed by a processor to implement an application program operation monitoring method. The display screen of the computer equipment can be a liquid crystal display screen or an electronic ink display screen, and the input device of the computer equipment can be a touch layer covered on the display screen, a key, a track ball or a touch pad arranged on the shell of the computer equipment, an external keyboard, a touch pad or a mouse and the like.

In one embodiment, there is provided a computer device comprising a memory storing a computer program and a processor implementing the following steps when the processor executes the computer program: receiving an entry operation of a module code, and detecting whether the entered module code contains a preset type of target statement or not according to the entry operation; if yes, generating a corresponding target label and label description according to the target statement, and adding the target label to the position of the target statement in the module code; when a compiling instruction is received, traversing the module code according to the compiling instruction, and extracting a target label; the target tag comprises a page jump tag; acquiring a label description corresponding to a page jump label; the label description comprises a plurality of page identifications and jump relations among the page identifications; sending the label description to a server, and enabling the server to construct a page jump monitoring graph of an application program corresponding to the module codes by taking the page identifications as nodes and taking jump relations among the page identifications as directed edges according to the received label descriptions corresponding to the module codes respectively; and receiving a page jump monitoring graph returned by the server.

In one embodiment, the module code includes page code; the processor, when executing the computer program, further performs the steps of: receiving a design request for a target page, and displaying a design window according to the design request, wherein the design window comprises a page editing area and a plurality of thumbnail icons; capturing the dragging operation of the thumbnail icon, acquiring an element code corresponding to the dragged thumbnail icon, and generating a page element corresponding to the thumbnail icon based on the element code; adding the page elements to corresponding positions of the page editing area according to the dragging operation, and recording the adding sequence of the page elements; when a page saving instruction is received, acquiring a preset template code according to the page saving instruction, and respectively adding element codes corresponding to a plurality of page elements to the template code according to the adding sequence of the plurality of page elements in the page editing area to obtain a target page and corresponding page codes.

In one embodiment, the target tag further comprises a function call tag; the label description also comprises a plurality of function identifications and calling relations among the function identifications; the processor, when executing the computer program, further performs the steps of: acquiring a label description corresponding to the function calling label; acquiring module version identifications corresponding to a plurality of function identifications in the label description; determining version information corresponding to the module code according to the calling relationship among the function identifiers; sending the version information to a server, so that the server respectively corresponds to the version information according to the received module codes, wherein the version information comprises the dependency relationship among the module version identifications; each module is taken as an independent node, each independent node comprises at least one sub-node, each sub-node corresponds to one module version identification, and a dependency relationship between the module version identifications is used for constructing a version dependency monitoring graph of an application program corresponding to the module code for the directed edge; and receiving the version dependence monitoring graph returned by the server.

In one embodiment, a computer device is provided, which may be a server, and its internal structure diagram may be as shown in fig. 10. The computer device includes a processor, a memory, a network interface, and a database connected by a system bus. Wherein the processor of the computer device is configured to provide computing and control capabilities. The memory of the computer device comprises a nonvolatile storage medium and an internal memory. The non-volatile storage medium stores an operating system, a computer program, and a database. The internal memory provides an environment for the operation of an operating system and computer programs in the non-volatile storage medium. The database of the computer equipment is used for page jump monitoring graphs corresponding to different application programs. The network interface of the computer device is used for communicating with an external terminal through a network connection. The computer program is executed by a processor to implement an application program operation monitoring method.

Those skilled in the art will appreciate that the configurations shown in fig. 9 and 10 are merely block diagrams of some configurations relevant to the present disclosure, and do not constitute a limitation on the computing devices to which the present disclosure may be applied, and that a particular computing device may include more or less components than those shown, or combine certain components, or have a different arrangement of components.

In one embodiment, there is provided a computer device comprising a memory storing a computer program and a processor implementing the following steps when the processor executes the computer program: receiving operation information uploaded by a plurality of terminals; the terminal receives the input operation of the module codes and detects whether the input module codes contain target sentences of preset types or not according to the input operation; if yes, generating a corresponding target label and label description according to the target statement, and adding the target label to the position of the target statement in the module code; when a compiling instruction is received, traversing the module code according to the compiling instruction, and extracting a target label; the target tag comprises a page jump tag; acquiring a label description corresponding to a page jump label; the operation information comprises a plurality of label descriptions; the label description comprises a plurality of page identifications and jump relations among the page identifications; constructing a page jump monitoring graph of the APP corresponding to the module codes by taking each page identifier as a node and taking the jump relation among the page identifiers as a directed edge; and pushing the page jump monitoring graph to a plurality of terminals.

In one embodiment, the target tag further comprises a function call tag; the label description also comprises a plurality of function identifications and calling relations among the function identifications; the processor, when executing the computer program, further performs the steps of: receiving version information uploaded by a plurality of terminals; the terminal acquires module version identifications corresponding to a plurality of function identifications in the label description respectively, and determines version information corresponding to module codes according to the calling relation among the function identifications; the version information comprises a dependency relationship among a plurality of module version identifications; each module is taken as an independent node, each independent node comprises at least one sub-node, each sub-node corresponds to one module version identification, and a dependency relationship among the module version identifications is used for constructing a version dependency monitoring graph for the directed edges; and pushing the version-dependent monitoring graph to a plurality of terminals.

In one embodiment, the processor, when executing the computer program, further performs the steps of: monitoring version updating dynamic state released by a terminal; the version updating dynamic carries version modification description information; determining an independent node dynamically corresponding to version updating in the version dependence monitoring graph, searching all directed edges connected with the independent node, and acquiring label description corresponding to the searched directed edges; comparing the obtained label description with the version modification description information to generate a directed edge modification strategy; and updating the version dependence monitoring graph according to the directed edge modification strategy, and pushing the updated version dependence monitoring graph to a plurality of terminals.

In one embodiment, the processor, when executing the computer program, further performs the steps of: distributing a monitoring graph identifier for the page jump monitoring graph; storing the page jump monitoring graph, and acquiring a storage address link corresponding to the page jump monitoring graph; associating the monitoring graph identifier with the storage address link; and generating a two-dimensional code according to the storage address link, and pushing the two-dimensional code to a plurality of terminals.

In one embodiment, a computer-readable storage medium is provided, having a computer program stored thereon, which when executed by a processor, performs the steps of: receiving an entry operation of a module code, and detecting whether the entered module code contains a preset type of target statement or not according to the entry operation; if yes, generating a corresponding target label and label description according to the target statement, and adding the target label to the position of the target statement in the module code; when a compiling instruction is received, traversing the module code according to the compiling instruction, and extracting a target label; the target tag comprises a page jump tag; acquiring a label description corresponding to a page jump label; the label description comprises a plurality of page identifications and jump relations among the page identifications; sending the label description to a server, and enabling the server to construct a page jump monitoring graph of an application program corresponding to the module codes by taking the page identifications as nodes and taking jump relations among the page identifications as directed edges according to the received label descriptions corresponding to the module codes respectively; and receiving a page jump monitoring graph returned by the server.

In one embodiment, the module code includes page code; the computer program when executed by the processor further realizes the steps of: receiving a design request for a target page, and displaying a design window according to the design request, wherein the design window comprises a page editing area and a plurality of thumbnail icons; capturing the dragging operation of the thumbnail icon, acquiring an element code corresponding to the dragged thumbnail icon, and generating a page element corresponding to the thumbnail icon based on the element code; adding the page elements to corresponding positions of the page editing area according to the dragging operation, and recording the adding sequence of the page elements; when a page saving instruction is received, acquiring a preset template code according to the page saving instruction, and respectively adding element codes corresponding to a plurality of page elements to the template code according to the adding sequence of the plurality of page elements in the page editing area to obtain a target page and corresponding page codes.

In one embodiment, the target tag further comprises a function call tag; the label description also comprises a plurality of function identifications and calling relations among the function identifications; the computer program when executed by the processor further realizes the steps of: acquiring a label description corresponding to the function calling label; acquiring module version identifications corresponding to a plurality of function identifications in the label description; determining version information corresponding to the module code according to the calling relationship among the function identifiers; sending the version information to a server, so that the server respectively corresponds to the version information according to the received module codes, wherein the version information comprises the dependency relationship among the module version identifications; each module is taken as an independent node, each independent node comprises at least one sub-node, each sub-node corresponds to one module version identification, and a dependency relationship between the module version identifications is used for constructing a version dependency monitoring graph of an application program corresponding to the module code for the directed edge; and receiving the version dependence monitoring graph returned by the server.

In one embodiment, a computer-readable storage medium is provided, having a computer program stored thereon, which when executed by a processor, performs the steps of: receiving operation information uploaded by a plurality of terminals; the terminal receives the input operation of the module codes and detects whether the input module codes contain target sentences of preset types or not according to the input operation; if yes, generating a corresponding target label and label description according to the target statement, and adding the target label to the position of the target statement in the module code; when a compiling instruction is received, traversing the module code according to the compiling instruction, and extracting a target label; the target tag comprises a page jump tag; acquiring a label description corresponding to a page jump label; the operation information comprises a plurality of label descriptions; the label description comprises a plurality of page identifications and jump relations among the page identifications; constructing a page jump monitoring graph of the APP corresponding to the module codes by taking each page identifier as a node and taking the jump relation among the page identifiers as a directed edge; and pushing the page jump monitoring graph to a plurality of terminals.

In one embodiment, the target tag further comprises a function call tag; the label description also comprises a plurality of function identifications and calling relations among the function identifications; the computer program when executed by the processor further realizes the steps of: receiving version information uploaded by a plurality of terminals; the terminal acquires module version identifications corresponding to a plurality of function identifications in the label description respectively, and determines version information corresponding to module codes according to the calling relation among the function identifications; the version information comprises a dependency relationship among a plurality of module version identifications; each module is taken as an independent node, each independent node comprises at least one sub-node, each sub-node corresponds to one module version identification, and a dependency relationship among the module version identifications is used for constructing a version dependency monitoring graph for the directed edges; and pushing the version-dependent monitoring graph to a plurality of terminals.

In one embodiment, the computer program when executed by the processor further performs the steps of: monitoring version updating dynamic state released by a terminal; the version updating dynamic carries version modification description information; determining an independent node dynamically corresponding to version updating in the version dependence monitoring graph, searching all directed edges connected with the independent node, and acquiring label description corresponding to the searched directed edges; comparing the obtained label description with the version modification description information to generate a directed edge modification strategy; and updating the version dependence monitoring graph according to the directed edge modification strategy, and pushing the updated version dependence monitoring graph to a plurality of terminals.

In one embodiment, the computer program when executed by the processor further performs the steps of: distributing a monitoring graph identifier for the page jump monitoring graph; storing the page jump monitoring graph, and acquiring a storage address link corresponding to the page jump monitoring graph; associating the monitoring graph identifier with the storage address link; and generating a two-dimensional code according to the storage address link, and pushing the two-dimensional code to a plurality of terminals.

It will be understood by those skilled in the art that all or part of the processes of the methods of the embodiments described above can be implemented by hardware related to instructions of a computer program, which can be stored in a non-volatile computer-readable storage medium, and when executed, can include the processes of the embodiments of the methods described above. Any reference to memory, storage, database, or other medium used in the embodiments provided herein may include non-volatile and/or volatile memory, among others. Non-volatile memory can include read-only memory (ROM), Programmable ROM (PROM), Electrically Programmable ROM (EPROM), Electrically Erasable Programmable ROM (EEPROM), or flash memory. Volatile memory can include Random Access Memory (RAM) or external cache memory. By way of illustration and not limitation, RAM is available in a variety of forms such as Static RAM (SRAM), Dynamic RAM (DRAM), Synchronous DRAM (SDRAM), Double Data Rate SDRAM (DDRSDRAM), Enhanced SDRAM (ESDRAM), Synchronous Link DRAM (SLDRAM), Rambus Direct RAM (RDRAM), direct bus dynamic RAM (DRDRAM), and memory bus dynamic RAM (RDRAM).

The technical features of the above embodiments can be arbitrarily combined, and for the sake of brevity, all possible combinations of the technical features in the above embodiments are not described, but should be considered as the scope of the present specification as long as there is no contradiction between the combinations of the technical features.

The above examples only express several embodiments of the present application, and the description thereof is more specific and detailed, but not construed as limiting the scope of the invention. It should be noted that, for a person skilled in the art, several variations and modifications can be made without departing from the concept of the present application, which falls within the scope of protection of the present application. Therefore, the protection scope of the present patent shall be subject to the appended claims.

Claims

1. An application program operation monitoring method, the method comprising:

receiving an entry operation of a module code written based on a preset frame, and detecting whether the entered module code contains a target statement of a preset type or not according to the entry operation through an information marking component in the preset frame, wherein the target statement contains a statement capable of representing the running condition of a corresponding application program;

if yes, generating a corresponding target label and label description according to the target statement, associating the target label with the label description, storing the associated label description to a specified directory, adding the target label to the position of the target statement in the module code, and distinguishing different display states of the same page through a page identifier and a state identifier;

when a compiling instruction is received, generating a callback instruction of an information extraction component in a preset frame, so that the information extraction component traverses the module code according to the callback instruction and the compiling instruction, and extracting the target tag, wherein the target tag comprises a page jump tag; acquiring a label description corresponding to the page jump label from a specified directory; the label description comprises a plurality of page identifications and a jump relation among the page identifications;

sending the label description to a server, and enabling the server to construct a page jump monitoring graph of an application program corresponding to the module codes by taking the page identifications as nodes and taking jump relations among the page identifications as directed edges according to the received label descriptions corresponding to the module codes respectively;

and receiving a page jump monitoring graph returned by the server.

2. The method of claim 1, wherein the module code comprises page code; the receiving of the entry operation of the module code written based on the preset framework comprises:

receiving a design request for a target page, and displaying a design window according to the design request, wherein the design window comprises a page editing area and a plurality of thumbnail icons;

capturing the dragging operation of the thumbnail icon, acquiring an element code corresponding to the dragged thumbnail icon, and generating a page element corresponding to the thumbnail icon based on the element code;

adding the page elements to corresponding positions of the page editing area according to the dragging operation, and recording the adding sequence of the page elements;

when a page saving instruction is received, acquiring a preset template code according to the page saving instruction, and respectively adding element codes corresponding to a plurality of page elements to the template code according to the adding sequence of the plurality of page elements in the page editing area to obtain the target page and the corresponding page codes.

3. The method of claim 1, wherein the target tag further comprises a function call tag; the label description also comprises a plurality of function identifications and calling relations among the function identifications; the method further comprises the following steps: acquiring a label description corresponding to the function calling label;

obtaining module version identifications corresponding to the function identifications in the label description respectively;

determining version information corresponding to the module code according to the calling relationship among the function identifiers;

sending the version information to the server, so that the server respectively corresponds to the version information according to the received module codes, wherein the version information comprises the dependency relationship among the module version identifiers; each module is taken as an independent node, each independent node comprises at least one sub-node, each sub-node corresponds to one module version identifier, and a dependency relationship among the module version identifiers is used for constructing a version dependency monitoring graph of an application program corresponding to a module code for a directed edge;

and receiving the version dependence monitoring graph returned by the server.

4. An application program operation monitoring method, the method comprising:

receiving operation information uploaded by a plurality of terminals; the terminal receives an entry operation of a module code written based on a preset frame, and detects whether the entered module code contains a target statement of a preset type or not according to the entry operation through an information marking component in the preset frame, wherein the target statement contains a statement capable of representing the running condition of a corresponding application program; if yes, generating a corresponding target label and label description according to the target statement, associating the target label with the label description, storing the associated label description to a specified directory, adding the target label to the position of the target statement in the module code, and distinguishing different display states of the same page through a page identifier and a state identifier; when a compiling instruction is received, generating a callback instruction of an information extraction component in a preset frame, so that the information extraction component traverses the module code according to the callback instruction and the compiling instruction, and extracting the target label; the target tag comprises a page jump tag; acquiring a label description corresponding to the page jump label from a specified directory; the operational information includes a plurality of the tag descriptions; the label description comprises a plurality of page identifications and jump relations among the page identifications;

constructing a page jump monitoring graph of the APP corresponding to the module codes by taking each page identifier as a node and taking the jump relation among the page identifiers as a directed edge;

and pushing the page jump monitoring graph to a plurality of terminals.

5. The method of claim 4, wherein the target tag further comprises a function call tag; the label description also comprises a plurality of function identifications and calling relations among the function identifications; the method further comprises the following steps:

receiving version information uploaded by a plurality of terminals; the terminal acquires module version identifications corresponding to the function identifications in the label description respectively, and determines version information corresponding to the module codes according to the calling relation among the function identifications; the version information comprises a dependency relationship among a plurality of module version identifications; each module is taken as an independent node, each independent node comprises at least one sub-node, each sub-node corresponds to one module version identification, and a version dependence monitoring graph is constructed for directed edges according to dependence relations among the module version identifications;

and pushing the version-dependent monitoring graph to a plurality of terminals.

6. The method of claim 5, further comprising:

monitoring the version updating dynamic state released by the terminal; the version updating dynamically carries version modification description information;

determining an independent node dynamically corresponding to the version updating in the version dependent monitoring graph, searching all directed edges connected with the independent node, and acquiring a label description corresponding to the searched directed edge;

comparing the acquired label description with the version modification description information to generate a directed edge modification strategy;

and updating the version dependence monitoring graph according to the directed edge modification strategy, and pushing the updated version dependence monitoring graph to a plurality of terminals.

7. The method according to claim 4, wherein the pushing the page jump monitoring graph to a plurality of terminals comprises:

distributing a monitoring graph identifier for the page jump monitoring graph;

storing the page jump monitoring graph, and acquiring a storage address link corresponding to the page jump monitoring graph;

associating the monitoring graph identification with the storage address link;

and generating a two-dimensional code according to the storage address link, and pushing the two-dimensional code to a plurality of terminals.

8. An application program operation monitoring apparatus, comprising:

the information marking module is used for receiving an input operation of a module code written based on a preset frame, and detecting whether the input module code contains a preset type of target statement or not according to the input operation through an information marking component in the preset frame; if the current display state of the corresponding application program is contained in the module code, generating a corresponding target label and label description according to the target statement, associating the target label with the label description, storing the associated label description to a specified directory, adding the target label to the position of the target statement in the module code, wherein the target statement comprises a statement capable of representing the running condition of the corresponding application program, and distinguishing different display states of the same page through page identification and state identification;

the information extraction module is used for generating a callback instruction of an information extraction component in a preset frame when the compiling instruction is received, so that the information extraction component traverses the module code according to the callback instruction and the compiling instruction, and extracts the target label; the target tag comprises a page jump tag; acquiring a label description corresponding to the page jump label from a specified directory; the label description comprises a plurality of page identifications and jump relations among the page identifications;

the operation monitoring module is used for sending the label description to a server, so that the server constructs a page jump monitoring graph of an application program corresponding to the module codes by taking the page identifications as nodes and taking the jump relation among the page identifications as directed edges according to the received label descriptions corresponding to the module codes respectively; and receiving a page jump monitoring graph returned by the server.

9. A computer device comprising a memory and a processor, the memory storing a computer program, wherein the processor when executing the computer program implements the steps of the method of any one of claims 1 to 3 or 4 to 7.

10. A computer-readable storage medium, on which a computer program is stored, which, when being executed by a processor, carries out the steps of the method of any one of claims 1 to 3 or 4 to 7.