Page performance data collection method, device and computing equipment

Abstract

The present invention discloses a method, device and computing equipment for collecting page performance data, wherein the method comprises: parsing a section file, using a cutter to weave a listening program into the page loading end method of a webview, and registering a JS listening program in the page loading end method; when the webview finishes loading the page, obtaining the page performance data returned by the JS callback; and storing the page performance data in a designated database. The scheme of the present invention uses a cutter to weave a listening program into the page loading end method of a webview, without the need for the data demander to manually write the listening program. It can be seen that the scheme of the present invention can realize the collection of page performance data without the demander's perception.

Description

Technical Field

[0001] The present invention relates to the field of computer technology, and in particular to a method, device and computing equipment for collecting page performance data. Background Art

[0002] With the development of mobile terminal technology, a large number of terminal applications for life, entertainment, and services have emerged. Existing terminal applications basically use a combination of Android native and H5 pages to display pages. At the same time, as business functions become more complex, pages become more complex, which can easily lead to slow page loading, which is usually unacceptable to users.

[0003] In the prior art, in order to clarify the specific reasons for slow page loading, the demander usually manually writes monitoring code into the Android native method to monitor the page loading data, and then uses this data to detect the specific reasons for slow page loading. Obviously, the method of collecting page loading data in the prior art must be implemented by the demander manually writing the monitoring code, which is difficult for the demander to implement. Summary of the invention

[0004] In view of the above problems, the present invention is proposed to provide a method, apparatus and computing device for collecting page performance data that overcome the above problems or at least partially solve the above problems.

[0005] According to one aspect of the present invention, a method for collecting page performance data is provided, comprising:

[0006] Parse the slice file, use the cutter to weave the listener into the page loading end method of webview, and register the JS listener in the page loading end method;

[0007] When the webview finishes loading the page, get the page performance data returned by the JS callback;

[0008] The page performance data is stored in a designated database.

[0009] According to another aspect of the present invention, there is provided a page performance data collection device, comprising:

[0010] A monitoring module, adapted to parse the slice file, weave the monitoring program into the page loading end device of the webview by using the cutter, and realize registering the JS monitoring in the page loading end device;

[0011] The callback module is used to obtain the page performance data returned by the JS callback when the webview finishes loading the page;

[0012] The storage module is adapted to store the page performance data in a designated database.

[0013] According to another aspect of the present invention, there is provided a computing device, comprising: a processor, a memory, a communication interface and a communication bus, wherein the processor, the memory and the communication interface communicate with each other via the communication bus;

[0014] The memory is used to store at least one executable instruction, and the executable instruction enables the processor to execute operations corresponding to the above-mentioned page performance data collection method.

[0015] According to another aspect of the present invention, a computer storage medium is provided, wherein the storage medium stores at least one executable instruction, and the executable instruction enables a processor to execute operations corresponding to the above-mentioned page performance data collection method.

[0016] According to the page performance data collection method, device and computing equipment of the present invention, the section file is parsed, and the listener is woven into the page loading end method of the webview using the inserter, so as to monitor the page performance data in the process of loading the page through the woven listener; then the page performance data returned by the JS callback is obtained and stored in the specified database for performance analysis. It can be seen that compared with the method in which the data demander manually writes the code and monitors, in the scheme of the present invention, the listener is woven into the page loading end method of the webview through the inserter, and the data demander does not need to write code, determine the specific entry point and insert the monitor, so that the page performance data can be collected without the data demander's perception.

[0017] The above description is only an overview of the technical solution of the present invention. In order to more clearly understand the technical means of the present invention, it can be implemented according to the contents of the specification. In order to make the above and other purposes, features and advantages of the present invention more obvious and easy to understand, the specific implementation methods of the present invention are listed below. BRIEF DESCRIPTION OF THE DRAWINGS

[0018] Various other advantages and benefits will become apparent to those of ordinary skill in the art by reading the detailed description of the preferred embodiments below. The accompanying drawings are only for the purpose of illustrating the preferred embodiments and are not to be considered as limiting the present invention. Moreover, the same reference symbols are used throughout the accompanying drawings to represent the same components. In the accompanying drawings:

[0019] Figure 1 A flow chart of a method for collecting page performance data according to an embodiment of the present invention is shown;

[0020] Figure 2 A flow chart of a method for collecting page performance data according to another embodiment of the present invention is shown;

[0021] Figure 3 It shows a functional block diagram of a page performance data collection device according to an embodiment of the present invention;

[0022] Figure 4 A schematic structural diagram of a computing device according to an embodiment of the present invention is shown. DETAILED DESCRIPTION

[0023] The exemplary embodiments of the present disclosure will be described in more detail below with reference to the accompanying drawings. Although the exemplary embodiments of the present disclosure are shown in the accompanying drawings, it should be understood that the present disclosure can be implemented in various forms and should not be limited by the embodiments set forth herein. On the contrary, these embodiments are provided to enable a more thorough understanding of the present disclosure and to fully convey the scope of the present disclosure to those skilled in the art.

[0024] Figure 1 A flow chart of a method for collecting page performance data according to an embodiment of the present invention is shown.

[0025] like Figure 1 As shown, the method includes:

[0026] Step S101: parse the slice file, use the cutter to weave the listening program into the page loading end method of the webview, and register the JS listening program in the page loading end method.

[0027] Specifically, before implementing the solution of the present invention, the writing of the section file is completed; the section file contains the entry path, entry point, and / or listening program, wherein the entry path is the path corresponding to the page loading end method. Also, when there is a need to collect page performance data, the SDK that implements the solution of the present invention is connected, and the SDK includes the section file; by parsing the section file, the corresponding entry path and entry point are determined, and then the listening program is woven into the entry point under the entry path using the cutter, and the JS listening program can be registered in the page loading end method.

[0028] It should be noted that the specific form of the cutter is not limited in the present invention, and in specific implementation, those skilled in the art can select a tool that can insert a program into the source code as the cutter according to actual conditions. Optionally, the cutter is AspectJ.

[0029] Step S102: When the webview finishes loading the page, obtain the page performance data returned by the JS callback.

[0030] Among them, the location of JS callback is the location of the entry point.

[0031] Specifically, when the entry point in the page loading end method is executed, the JS callback will receive the corresponding notification, which is the returned page performance data. Correspondingly, when the webview finishes loading the page, the listener will collect the corresponding page performance data for each entry point. Among them, page performance data refers to data reflecting the loading time of one or more resources during the page loading process.

[0032] Step S103: Store the page performance data in a designated database.

[0033] The designated database is usually designated by the data demander. Optionally, the data demander is an application provider.

[0034] After obtaining the page performance data, it is stored in the specified database to facilitate analysis of the reasons for slow page loading.

[0035] According to the page performance data collection method provided by this embodiment, by parsing the section file, and using the cutter to weave the listening program into the page loading end method of the webview, the page performance data in the process of loading the page can be monitored through the woven listening program; then the page performance data returned by the JS callback is obtained and stored in the specified database for performance analysis. It can be seen that compared with the method in which the data demander manually writes the code and monitors, in the scheme of this embodiment, after the application accesses the SDK that implements this scheme, the listening program is woven into the page loading end method of the webview through the cutter, and the data demander does not need to write code, determine the specific entry point and insert the listening program, so that the page performance data can be collected without the data demander's perception.

[0036] Figure 2 FIG. 2 shows a flow chart of a method for collecting page performance data according to another embodiment of the present invention. Figure 2 As shown, the method includes:

[0037] Step S201: parse the slice file, use the slicer to weave the listening program into the page loading end method of the webview, and register the JS listening program in the page loading end method.

[0038] Specifically, the aspect file is parsed to obtain the webview to be monitored and at least one entry point, wherein the webview to be monitored is the webview that currently needs to collect page performance data, and at least one entry point is the location where the listening program is woven in the page loading end method, and the at least one entry point can be determined according to the corresponding code when each resource in the webview to be monitored is loaded. The source code file corresponding to the webview to be monitored is obtained, and the process of weaving the listening program is completed in the compilation stage, then the source code file corresponding to the webview to be monitored needs to be obtained for rewriting and compilation. The listener is woven into the position of the page loading end method of the webview to be monitored corresponding to at least one entry point by using an inserter, so as to complete the rewriting of the page loading end method of the webview to be monitored, wherein the inserter can also be regarded as a compiler, which identifies the entry point specified in the aspect file, and the entry point reflects the specific class, specific method and / or specific field to be monitored; accordingly, the listener is woven into the position corresponding to the entry point in the source code file, so as to complete the rewriting of the page loading end method, and the listener woven into the entry point can be used for the collection of the corresponding page performance data. The source code file corresponding to the rewritten webview to be monitored is stored in the specified directory, wherein the specified directory is the storage path corresponding to the page loading end method, so as to ensure the normal execution of the page loading end method and the listener during the page loading process, and then collect the corresponding page performance data.

[0039] Furthermore, for different system versions, there are differences in the entry points for collecting the corresponding page performance data. Based on this, the section files corresponding to each system version are written so that when collecting page performance data, the section files corresponding to the current system version are used to rewrite the source code, thereby improving the accuracy of the collection results. Accordingly, before parsing the section files, multiple section files for different system versions are obtained, and the section files that match the system version of the webview to be monitored are identified. Among them, in the actual application of Android native systems, major manufacturers usually make certain modifications to the Android native system in order to adapt to different needs, and different improved system versions will appear. At this time, for multiple system versions, if the data demander only relies on manually writing code to realize the collection of page performance data, the adjustment is difficult, which will bring about the problem of high modification cost or inaccurate collection results. In this embodiment, multiple section files for different system versions are placed in the SDK that implements the solution of the present invention, and the corresponding section files are accurately determined by active matching. Then, after accessing the SDK, accurate page performance data can be collected without the participation of the data demander. Furthermore, parsing a slice file means parsing a matching slice file.

[0040] For example, write three sets of slice files a, b and c for three system versions A, B and C. If the system version of the webview to be monitored is B, filter out slice files a and c, and only parse slice file b.

[0041] In addition, in this embodiment, the page loading end method includes a method reflecting the completion of loading of all page resources and / or a method reflecting the completion of loading of a unit page resource. Optionally, the page loading end method is an onPageFinished method.

[0042] Step S202: When the webview finishes loading the page, obtain the page performance data returned by the JS callback.

[0043] The page performance data is generated during the webview loading process. For example, the page performance data is the time required for all page resources to be loaded, or the page performance data is the time of the white screen.

[0044] Specifically, whenever the webview successfully loads a page, or when the loading is completed, the JS callback will receive a response, and after receiving the response, it will pass over a json string, and the data in this json string is the page performance data of the entire webview.

[0045] Step S203: Analyze the page performance data, and perform deduplication processing on the page performance data according to the analysis result.

[0046] Manufacturers modify Android native components such as webview client to implement extended functions, which may cause the page loading end method to be executed multiple times. For example, the onPageFinished() method is executed multiple times. At this time, the page performance data returned by the callback may be repeated. Based on this, the page performance data is deduplicated.

[0047] Specifically, in the json string returned by the JS callback, only the data when the page progress is loaded to 100% is collected as the page performance data of the webview, which can avoid duplication of page performance data. Furthermore, after the page progress is loaded to 100%, the json string returned by the JS callback will be received, and the callback will be marked, such as adding a Boolean variable; when the callback is executed thereafter, it is determined whether the collection operation needs to be performed based on the Boolean variable. For example, when the callback is executed again for the above 100% progress, no operation is performed, thereby further avoiding duplication of page performance data.

[0048] Step S204: Store the page performance data in a designated database.

[0049] Specifically, the page performance data is distributed to the dispatchToAopWebTrace method, that is, the data in the json string is distributed to the dispatchToAopWebTrace method; then, the dispatchToAopWebTrace method is executed to store the page performance data in the specified database. Optionally, the data in the database is uploaded to the cloud at a specific time for big data analysis.

[0050] In some optional embodiments, before executing step S204, the monitored page performance data is first filtered. If some of the monitored page performance data cannot be effectively used to analyze the reasons for slow page loading, then this part of the page performance data can be eliminated to save storage space.

[0051] The core code content of a specific embodiment is listed below to assist those skilled in the art in understanding the specific implementation process of this embodiment:

[0052]

[0053]

[0054]

[0055]

[0056] According to the page performance data collection method provided by this embodiment, a section file corresponding to multiple different system versions is written. When the listening program is woven into the page loading end method, the section file corresponding to the system version of the current webview is identified through matching of the system version, and the listening program is registered according to the section file, which is conducive to accurately listening to the page performance data of the corresponding system; and, the entry point in the section file is identified by using the sectioner, and the listening program is automatically woven into the page loading end method of the webview to realize the registration of the JS listening program in the page loading end method. There is no need for the data demander to write code, determine the specific entry point and insert the listening program, and the page performance data can be collected without the data demander's perception. It can be seen from this that the scheme of this embodiment, with the help of the sectioner, realizes the weaving of the code, avoids the manual configuration of the demander, and the demander only needs to access the SDK, and does not need to worry about anything else, and can collect the corresponding H5 page performance data.

[0057] Figure 3 FIG. 4 shows a functional block diagram of a page performance data collection device according to an embodiment of the present invention. Figure 3 As shown, the device comprises:

[0058] The monitoring module 301 is adapted to parse the slice file, and use the cutter to weave the monitoring program into the page loading end device of the webview, so as to register the JS monitoring in the page loading end device;

[0059] The callback module 302 is adapted to obtain the page performance data returned by the JS callback when the webview finishes loading the page;

[0060] The storage module 303 is adapted to store the page performance data in a designated database.

[0061] In an optional implementation, the monitoring module 301 is further adapted to:

[0062] Parse the slice file to obtain the webview to be monitored and at least one entry point;

[0063] Get the source code file corresponding to the webview to be monitored;

[0064] Using the cutter, weaving the listening program into the position of the page loading end device of the webview to be monitored corresponding to the at least one entry point, completing the rewriting of the page loading end device of the webview to be monitored;

[0065] The rewritten source code file corresponding to the webview to be monitored is stored in the specified directory.

[0066] In an optional implementation, the monitoring module 301 is further adapted to:

[0067] Get multiple slice files for different system versions, and identify the slice file that matches the system version of the webview to be monitored;

[0068] Parse the matching aspect files.

[0069] In an optional embodiment, the device further comprises:

[0070] The deduplication module 304 is adapted to analyze the page performance data and perform deduplication processing on the page performance data according to the analysis result.

[0071] In an optional implementation, the page loading completion method is the onPageFinished method.

[0072] In an optional implementation, the storage module 303 is further adapted to: distribute the page performance data to the dispatchToAopWebTrace method, and execute the dispatchToAopWebTrace method to store the page performance data in a designated database.

[0073] An embodiment of the present application provides a non-volatile computer storage medium, wherein the computer storage medium stores at least one executable instruction, and the computer executable instruction can execute the page performance data collection method in any of the above method embodiments.

[0074] Figure 4 A schematic diagram of the structure of a computing device according to an embodiment of the present invention is shown. The specific embodiment of the present invention does not limit the specific implementation of the computing device.

[0075] like Figure 4 As shown, the computing device may include: a processor (processor) 402 , a communications interface (Communications Interface) 404 , a memory (memory) 406 , and a communication bus 408 .

[0076] in:

[0077] The processor 402 , the communication interface 404 , and the memory 406 communicate with each other via a communication bus 408 .

[0078] The communication interface 404 is used to communicate with other devices such as clients or other servers.

[0079] The processor 402 is used to execute the program 410, and specifically can execute the relevant steps in the above-mentioned embodiment of the page performance data collection method.

[0080] Specifically, the program 410 may include program codes, which include computer operation instructions.

[0081] The processor 402 may be a central processing unit (CPU), or an application-specific integrated circuit (ASIC), or one or more integrated circuits configured to implement the embodiments of the present invention. The one or more processors included in the computing device may be processors of the same type, such as one or more CPUs; or processors of different types, such as one or more CPUs and one or more ASICs.

[0082] The memory 406 is used to store the program 410. The memory 406 may include a high-speed RAM memory, and may also include a non-volatile memory (non-volatile memory), such as at least one disk memory.

[0083] The program 410 may be specifically configured to enable the processor 402 to perform the following operations:

[0084] Parse the slice file, use the cutter to weave the listener into the page loading end method of webview, and register the JS listener in the page loading end method;

[0085] When the webview finishes loading the page, get the page performance data returned by the JS callback;

[0086] The page performance data is stored in a designated database.

[0087] In an optional implementation, the program 410 may be specifically used to further enable the processor 402 to perform the following operations:

[0088] Parse the slice file to obtain the webview to be monitored and at least one entry point;

[0089] Get the source code file corresponding to the webview to be monitored;

[0090] Using the cutter, weave the listening program into the position corresponding to the at least one cut-in point of the page loading end method of the webview to be monitored, and complete the rewriting of the page loading end method of the webview to be monitored;

[0091] The rewritten source code file corresponding to the webview to be monitored is stored in the specified directory.

[0092] In an optional implementation, the program 410 may be specifically used to further enable the processor 402 to perform the following operations:

[0093] Get multiple slice files for different system versions, and identify the slice file that matches the system version of the webview to be monitored;

[0094] Parse the matching aspect files.

[0095] In an optional implementation, the program 410 may be specifically used to further enable the processor 402 to perform the following operations:

[0096] The page performance data is analyzed, and deduplication processing is performed on the page performance data according to the analysis result.

[0097] In an optional implementation, the page loading completion method is the onPageFinished method.

[0098] In an optional implementation, the program 410 may be specifically used to further enable the processor 402 to perform the following operations: distribute the page performance data to the dispatchToAopWebTrace method, and execute the dispatchToAopWebTrace method to store the page performance data in a designated database.

[0099] The algorithm and display provided herein are not inherently related to any particular computer, virtual system or other device. Various general purpose systems can also be used together with the teachings based on this. According to the above description, it is obvious that the structure required for constructing such systems. In addition, the present invention is not directed to any specific programming language either. It should be understood that various programming languages ​​can be utilized to realize the content of the present invention described herein, and the description of the above specific languages ​​is for disclosing the best mode of the present invention.

[0100] In the description provided herein, a large number of specific details are described. However, it is understood that embodiments of the present invention can be practiced without these specific details. In some instances, well-known methods, structures and techniques are not shown in detail so as not to obscure the understanding of this description.

[0101] Similarly, it should be understood that in order to streamline the present disclosure and aid in understanding one or more of the various inventive aspects, in the above description of exemplary embodiments of the present invention, various features of the present invention are sometimes grouped together into a single embodiment, figure, or description thereof. However, this disclosed method should not be interpreted as reflecting the intention that the claimed invention requires more features than those explicitly recited in each claim. More specifically, as reflected in the claims below, inventive aspects lie in less than all the features of the individual embodiments disclosed above. Therefore, the claims that follow the specific embodiment are hereby expressly incorporated into the specific embodiment, with each claim itself serving as a separate embodiment of the present invention.

[0102] Those skilled in the art will appreciate that the modules in the devices in the embodiments may be adaptively changed and arranged in one or more devices different from the embodiments. The modules or units or components in the embodiments may be combined into one module or unit or component, and in addition they may be divided into a plurality of submodules or subunits or subcomponents. Except that at least some of such features and / or processes or units are mutually exclusive, all features disclosed in this specification (including the accompanying claims, abstracts and drawings) and all processes or units of any method or device disclosed in this manner may be combined in any combination. Unless otherwise expressly stated, each feature disclosed in this specification (including the accompanying claims, abstracts and drawings) may be replaced by an alternative feature providing the same, equivalent or similar purpose.

[0103] In addition, those skilled in the art will appreciate that, although some embodiments described herein include certain features included in other embodiments but not other features, the combination of features of different embodiments is meant to be within the scope of the present invention and form different embodiments. For example, in the claims below, any one of the claimed embodiments may be used in any combination.

[0104] The various component embodiments of the present invention may be implemented in hardware, or in software modules running on one or more processors, or in a combination thereof. It should be understood by those skilled in the art that a microprocessor or a digital signal processor (DSP) may be used in practice to implement some or all of the functions of some or all of the components in the page performance data acquisition device according to an embodiment of the present invention. The present invention may also be implemented as a device or device program (e.g., a computer program and a computer program product) for executing part or all of the methods described herein. Such a program implementing the present invention may be stored on a computer-readable medium, or may be in the form of one or more signals. Such a signal may be downloaded from an Internet website, or provided on a carrier signal, or provided in any other form.

[0105] It should be noted that the above embodiments illustrate the present invention rather than limit it, and that those skilled in the art may devise alternative embodiments without departing from the scope of the appended claims. In the claims, any reference symbol between brackets shall not be construed as a limitation on the claims. The word "comprising" does not exclude the presence of elements or steps not listed in the claims. The word "one" or "an" preceding an element does not exclude the presence of a plurality of such elements. The present invention may be implemented by means of hardware comprising a number of different elements and by means of a suitably programmed computer. In a unit claim enumerating a number of devices, several of these devices may be embodied by the same hardware item. The use of the words first, second, and third, etc., does not indicate any order. These words may be interpreted as names.

Claims

1. A method for collecting page performance data, comprising: Parse the slice file, use the cutter to weave the listener into the page loading end method of webview, and register the JS listener in the page loading end method; When the webview finishes loading the page, get the page performance data returned by the JS callback; Storing the page performance data in a specified database; Among them, the parsing section file and using the cutter to weave the listening program into the page loading end method of the webview further include: Parse the slice file to obtain the webview to be monitored and at least one entry point; Get the source code file corresponding to the webview to be monitored; In the compilation stage, the listener is woven into the position of the page loading end method of the webview to be monitored corresponding to the at least one entry point by using the cutter, so as to complete the rewriting of the page loading end method of the webview to be monitored; The rewritten source code file corresponding to the webview to be monitored is stored in the specified directory.

2. The method according to claim 1, wherein: The parsing section file further includes: Get multiple slice files for different system versions, and identify the slice file that matches the system version of the webview to be monitored; Parse the matching aspect files.

3. The method according to claim 1, wherein: After obtaining the page performance data returned by the JS callback, the method further includes: The page performance data is analyzed, and deduplication processing is performed on the page performance data according to the analysis result.

4. The method according to claim 1, wherein: The page loading end method is the onPageFinished method.

5. The method according to any one of claims 1 to 4, wherein: The storing the page performance data in the designated database further includes: distributing the page performance data to the dispatchToAopWebTrace method, and executing the dispatchToAopWebTrace method to store the page performance data in the designated database.

6. A page performance data collection device, comprising: A monitoring module, adapted to parse the slice file, weave the monitoring program into the page loading end device of the webview by using the cutter, and realize registering the JS monitoring in the page loading end device; The callback module is used to obtain the page performance data returned by the JS callback when the webview finishes loading the page; A storage module, adapted to store the page performance data in a designated database; Wherein, the monitoring module is further adapted to: Parse the slice file to obtain the webview to be monitored and at least one entry point; Get the source code file corresponding to the webview to be monitored; In the compilation stage, the listener is woven into the position of the page loading end device of the webview to be monitored corresponding to the at least one entry point by using the cutter, so as to complete the rewriting of the page loading end device of the webview to be monitored; The rewritten source code file corresponding to the webview to be monitored is stored in the specified directory.

7. The device according to claim 6, wherein: The monitoring module is further adapted to: Get multiple slice files for different system versions, and identify the slice file that matches the system version of the webview to be monitored; Parse the matching aspect files.

8. The device according to claim 6, wherein: The device also includes: The deduplication module is suitable for analyzing the page performance data and performing deduplication processing on the page performance data according to the analysis result.

9. The device according to claim 6, wherein: The page loading end method is the onPageFinished method.

10. The device according to any one of claims 6 to 9, wherein: The storage module is further adapted to: distribute the page performance data to the dispatchToAopWebTrace method, and execute the dispatchToAopWebTrace method to store the page performance data in a designated database.

11. A computing device comprising: A processor, a memory, a communication interface and a communication bus, wherein the processor, the memory and the communication interface communicate with each other via the communication bus; The memory is used to store at least one executable instruction, and the executable instruction enables the processor to perform operations corresponding to the page performance data collection method as described in any one of claims 1-5.

12. A computer storage medium, wherein at least one executable instruction is stored in the storage medium, and the executable instruction enables a processor to execute operations corresponding to the page performance data collection method as described in any one of claims 1-5.

Images