Log block processing method and device, electronic equipment and storage medium

Abstract

The invention provides a log block processing method and device, electronic equipment and a storage medium, and relates to the field of artificial intelligence, in particular to the technical fields of NLP, deep learning, cloud computing, big data and the like. According to the specific implementation scheme, at least one first log block associated with the same function page in a target application is read from a log database associated with the target application; in response to the fact that the log type to which the first log block belongs is a performance log, querying a reference fluctuation trend of at least one performance index associated with the same function page; predicting whether the first log block has a performance problem based on the reference fluctuation trend of the at least one performance index; and if the performance problem exists, processing the first log block by adopting a first processing strategy matched with the performance problem.

Description

Technical Field

[0001] The present disclosure relates to the field of AI (Artificial Intelligence), specifically to technical fields such as NLP (Natural Language Processing), deep learning, cloud computing, big data, and especially to a log block processing method, device, electronic device, and storage medium. Background Art

[0002] When using APP (Application, including but not limited to: mobile applications, desktop applications, web applications), users may encounter various problems, such as interface freezes, functional abnormalities, data loading failures, etc. These problems not only affect the user experience, but are also key indicators for evaluating APP quality. Therefore, timely discovery and resolution of these problems is crucial to ensuring APP performance and user satisfaction. Summary of the invention

[0003] The present disclosure provides a method, device, electronic device and storage medium for processing log blocks.

[0004] According to one aspect of the present disclosure, a log block processing method is provided, comprising:

[0005] Reading, from a log database associated with a target application, at least one first log block associated with a same function page in the target application;

[0006] In response to the log type to which the first log block belongs being a performance log, querying a reference fluctuation trend of at least one performance indicator associated with the same function page;

[0007] Predicting whether the first log block has a performance problem based on a reference fluctuation trend of the at least one performance indicator;

[0008] If so, a first processing strategy adapted to the performance issue is adopted to process the first log block.

[0009] According to another aspect of the present disclosure, a log block processing device is provided, comprising:

[0010] A reading module, configured to read at least one first log block associated with the same function page in the target application from a log database associated with the target application;

[0011] A first query module, configured to query a reference fluctuation trend of at least one performance indicator associated with the same function page in response to the log type to which the first log block belongs being a performance log;

[0012] A prediction module, configured to predict whether the first log block has a performance problem based on a reference fluctuation trend of the at least one performance indicator;

[0013] The first processing module is used to process the first log block by adopting a first processing strategy adapted to the performance problem, if any.

[0014] According to another aspect of the present disclosure, there is provided an electronic device, comprising:

[0015] at least one processor; and

[0016] a memory communicatively connected to the at least one processor; wherein,

[0017] The memory stores instructions that can be executed by the at least one processor, and the instructions are executed by the at least one processor so that the at least one processor can execute the log block processing method proposed in the above aspect of the present disclosure.

[0018] According to another aspect of the present disclosure, a non-transitory computer-readable storage medium of computer instructions is provided, wherein the computer instructions are used to enable the computer to execute the log block processing method proposed in the above aspect of the present disclosure.

[0019] According to another aspect of the present disclosure, a computer program product is provided, including a computer program, wherein when the computer program is executed by a processor, the computer program implements the log block processing method proposed in the above aspect of the present disclosure.

[0020] It should be understood that the content described in this section is not intended to identify the key or important features of the embodiments of the present disclosure, nor is it intended to limit the scope of the present disclosure. Other features of the present disclosure will become easily understood through the following description. BRIEF DESCRIPTION OF THE DRAWINGS

[0021] The accompanying drawings are used to better understand the present solution and do not constitute a limitation of the present disclosure.

[0022] Figure 1 A flowchart of a log block processing method provided in the first embodiment of the present disclosure;

[0023] Figure 2 A flow chart of a log block processing method provided in the second embodiment of the present disclosure;

[0024] Figure 3 A flowchart of a log block processing method provided in Embodiment 3 of the present disclosure;

[0025] Figure 4 A flowchart of a log block processing method provided in Embodiment 4 of the present disclosure;

[0026] Figure 5 A flowchart of a log block processing method provided in Embodiment 5 of the present disclosure;

[0027] Figure 6 A schematic diagram of the implementation principle of user trace log recording and concatenation provided in an embodiment of the present disclosure;

[0028] Figure 7 A schematic diagram of the log concatenation process provided by an embodiment of the present disclosure;

[0029] Figure 8 A schematic diagram of the implementation principle of problem sniffing and alarm based on machine learning provided in an embodiment of the present disclosure;

[0030] Fig. 9 A schematic diagram of an application scenario of an embodiment of the present disclosure;

[0031] Fig.10 A schematic diagram of the structure of a log block processing device provided in Embodiment 6 of the present disclosure;

[0032] Fig.11 A schematic block diagram of an example electronic device that can be used to implement embodiments of the present disclosure is shown. DETAILED DESCRIPTION

[0033] The following is a description of exemplary embodiments of the present disclosure in conjunction with the accompanying drawings, including various details of the embodiments of the present disclosure to facilitate understanding, which should be considered as merely exemplary. Therefore, it should be recognized by those of ordinary skill in the art that various changes and modifications may be made to the embodiments described herein without departing from the scope and spirit of the present disclosure. Similarly, for the sake of clarity and conciseness, descriptions of well-known functions and structures are omitted in the following description.

[0034] In related technologies, the following solutions are mainly used to detect user problems:

[0035] The first one is network packet sniffing: using specific sniffing tools (such as wireshark (an open source packet capture tool or network sniffer used to analyze network traffic and data packets), sniffer (a network sniffer based on the principle of "passive listening"), etc.) to capture the network traffic generated by users when using applications, and analyze the users' network interaction behaviors and possible problems based on the network traffic.

[0036] This method can accurately capture the details of data transmission and help discover network-level anomalies, such as network delays, data transmission errors, data loss, or encryption issues.

[0037] The second type is log analysis: APP usually records the user's operation logs, including the pages visited, the operations performed, and the errors that occurred. By analyzing these logs, you can track the user's behavior trajectory and discover potential problems and anomalies.

[0038] That is, log analysis provides a detailed timeline of user behavior, making it easier for developers to quickly locate problems and trace their sources.

[0039] The third type is performance monitoring: Use performance monitoring tools to monitor the running status of the APP in real time, including CPU (Central Processing Unit) usage, memory usage, response time, etc., and discover potential performance problems such as interface freezes or resource leaks by comparing performance indicators under normal circumstances.

[0040] This method can monitor the running performance of the APP in real time, prevent potential performance bottlenecks, detect performance degradation trends before users perceive the problem, and make timely adjustments.

[0041] The fourth method is user feedback collection: by setting up feedback channels within the APP, users can get feedback on problems encountered during use. Although this method relies on the active participation of users, it can directly obtain users' real experience and problems encountered, providing developers with valuable improvement suggestions.

[0042] Among them, user feedback usually contains real usage scenarios and problem descriptions, which are of great value for improving products.

[0043] However, the first method mentioned above may require specific network permissions, and has certain difficulties in parsing encrypted data, and can only detect network problems, but cannot solve problems for users who do not use the network.

[0044] In the second method mentioned above, the level of detail of the log is related to the logging strategy of the APP. Too brief logs may provide limited information, and complex logs may be processed slowly, affecting the processing time.

[0045] In the third method mentioned above, the collection and analysis of performance data requires professional tools and technical support, and is not real-time enough. It can only detect performance problem monitoring, but has no monitoring capability for functional problems that occur during user use.

[0046] That is, packet sniffing can only detect network problems, and performance monitoring can only detect partial performance, with single functions.

[0047] In the fourth method mentioned above, user feedback is delayed and needs to be classified and processed, which means that developers can only perceive it after reaching a certain number, which will have a negative impact on the product.

[0048] Therefore, in order to address at least one of the above problems, the present disclosure provides a log block processing method, device, electronic device and storage medium.

[0049] The following describes the log block processing method, device, electronic device and storage medium according to the embodiments of the present disclosure with reference to the accompanying drawings.

[0050] Figure 1 The present invention is a flowchart of a log block processing method provided in the first embodiment of the present invention.

[0051] The execution subject of the embodiment of the present disclosure may be a client of the target application, or an SDK (Software Development Kit) connected to or integrated in the client.

[0052] There is no restriction on the application category to which the target application belongs. For example, the target application may be a social application, a shopping application, a game application, an educational application, a news application, etc.

[0053] The target applications include but are not limited to: mobile applications, desktop applications, web applications, etc.

[0054] like Figure 1 As shown, the log block processing method may include the following steps S101 to S104:

[0055] Step S101 : reading at least one first log block associated with the same function page in the target application from a log database associated with the target application.

[0056] The same log block includes all log records generated by a function page during its usage cycle, where the usage cycle refers to the period from when the user starts interacting with the function page (i.e., opens the function page) to when the user ends the interaction (i.e., exits the function page).

[0057] Exemplarily, the first log block may include a log block generated during a previous interaction between the user and the same function page, a log block generated during a current interaction between the user and the same function page, and the like.

[0058] The log database may also be referred to as a user log database, which is used to store log blocks generated when a user uses various function pages of a target application.

[0059] Among them, the function page usually refers to a specific screen or view that the user accesses after clicking a certain control or link in the target application, and the screen or view provides the user with a specific function or service. Among them, the function page is an important part of the target application, which provides the user with an interface to interact with the target application, enabling the user to complete a specific task or obtain the required information.

[0060] That is, the design of the function page usually revolves around a specific goal or function. Taking the target application as a shopping application as an example, the "shopping cart" page in a shopping application is a typical function page, which allows users to view the items added to the shopping cart and adjust the quantity, delete, and check out.

[0061] In an embodiment of the present disclosure, the execution entity can read at least one first log block associated with the same function page in the target application from a log database associated with the target application, that is, the first log block includes all log records generated by the same function page during its usage cycle.

[0062] For example, assuming that the user opens function page A in the target application at 10:00, exits function page A at 10:10, re-enters function page A at 10:15, and exits function page A at 10:20, then two first log blocks associated with function page A can be read from the log database, one of which includes all log records generated by function page A during the period from 10:00 to 10:10, and the other first log block includes all log records generated by function page A during the period from 10:15 to 10:20.

[0063] Step S102: In response to the log type to which the first log block belongs being a performance log, query a reference fluctuation trend of at least one performance indicator associated with the same function page.

[0064] The log types include, but are not limited to, identification logs, performance logs, and error logs.

[0065] Among them, identification log: has no special meaning and is used to identify log blocks and user actions.

[0066] Among them, the error log is used to record the errors that occur when the target application is running, indicating that there are functional problems in the target application.

[0067] Among them, the performance log is used to record the request time of the function page, the opening time of the function page, the heat change information, etc. This information will not be directly fed back by the user, but it will affect the user experience.

[0068] The performance indicators associated with different function pages may be the same or different, and the embodiments of the present disclosure do not limit this. For example, the performance indicators include, but are not limited to, request time, page opening time or page rendering time, heat change, and other indicators.

[0069] Among them, the reference fluctuation trend can also be called a reference trend, which is used to indicate the normal fluctuation range of performance indicators within a certain time range.

[0070] Exemplarily, the reference fluctuation trend of each performance indicator associated with the same function page can be determined by the server based on various log blocks associated with the same function page received from massive client feedback, and sent to the execution subject of the present disclosure.

[0071] Exemplarily, the reference fluctuation trend of each performance indicator associated with the same function page may also be determined in advance based on the history log block associated with the same function page, wherein the history log block and the first log block include log records generated during the interaction between the same user and the same function page.

[0072] In an embodiment of the present disclosure, when the log type to which the first log block belongs is a performance log, the execution subject may query a reference fluctuation trend of at least one performance indicator associated with the same function page.

[0073] Step S103: predicting whether there is a performance problem in the first log block based on a reference fluctuation trend of at least one performance indicator.

[0074] In the embodiment of the present disclosure, it is possible to predict whether the first log block has a performance problem based on a reference fluctuation trend of at least one performance indicator associated with the same functional page.

[0075] Exemplarily, a performance prediction model can be used to predict the probability that the first log block has a performance problem based on the reference fluctuation trend of at least one performance indicator associated with the same functional page mentioned above, that is, to predict the probability that the first log block is a degraded performance log. Thereafter, it can be determined whether the probability is higher than a set probability threshold (such as 0.8, 0.9, etc.). If so, it is determined that the first log block has a significantly degraded performance problem. At this time, step S104 can be further executed. If not, it is determined that the first log block does not have a significantly degraded performance problem. At this time, other log blocks can continue to be read from the log database to return to execute step S101 and subsequent steps.

[0076] Among them, performance prediction models include but are not limited to: LSTM (Long Short-Term Memory), SVM (Support Vector Machine), logistic regression, neural network and other models.

[0077] Step S104: If yes, use a first processing strategy adapted to the performance issue to process the first log block.

[0078] In an embodiment of the present disclosure, when there is a performance problem in the first log block, a first processing strategy adapted to the performance problem can be adopted to process the first log block, so as to achieve timely processing of the performance problem in the first log block, avoid the performance problem from continuing to expand and causing negative impact on the target application, thereby improving the user experience.

[0079] The log block processing method of the disclosed embodiment predicts whether there is a performance problem in the first log block associated with the same function page by using a reference fluctuation trend of at least one performance indicator associated with the same function page, which can improve the automation, timeliness and accuracy of performance problem discovery and can proactively predict potential performance problems. Once there is a performance problem in the first log block, the first processing strategy adapted to the performance problem is used to process the first log block, so that the performance problem in the first log block can be processed in a timely manner to avoid the performance problem from continuing to expand and causing a negative impact on the target application, thereby improving the user experience. In addition, by connecting or integrating all log records of the same function page within the usage cycle into one log block, it is possible to quickly lock the source of the problem when a performance problem occurs in a certain log block, thereby accelerating the repair process of the target application.

[0080] It should be noted that in the technical solution of the present disclosure, the collection, storage, use, processing, transmission, provision and disclosure of user personal information are all carried out with the user's consent, and are in compliance with relevant laws and regulations and do not violate public order and good morals.

[0081] In order to clearly explain how any embodiment of the present disclosure predicts whether a first log block has a performance problem based on a reference fluctuation trend of at least one performance indicator, the present disclosure also proposes a log block processing method.

[0082] Figure 2 This is a flow chart of the log block processing method provided in the second embodiment of the present disclosure.

[0083] like Figure 2 As shown, the log block processing method may include the following steps S201 to S207:

[0084] Step S201 : reading at least one first log block associated with the same function page in the target application from a log database associated with the target application.

[0085] Step S202: In response to the log type to which the first log block belongs being a performance log, query a reference fluctuation trend of at least one performance indicator associated with the same function page.

[0086] It should be noted that the explanation of steps S201 to S202 can be found in the relevant description in any embodiment of the present disclosure and will not be repeated here.

[0087] Step S203, obtaining the history log block associated with the same function page.

[0088] The historical log block and the first log block are both associated with the same user, that is, the historical log block and the first log block include log records generated during the process of the same user interacting with the same functional page.

[0089] Step S204: predicting the probability of a performance problem existing in the first log block according to the historical log block and the reference fluctuation trend of at least one performance indicator.

[0090] In the disclosed embodiment, the historical log blocks associated with the same functional page and the reference fluctuation trend of at least one performance indicator can be simultaneously integrated to predict the probability that the first log block has a performance problem, that is, to predict the probability that the first log block is a degraded performance log.

[0091] As an example, a performance prediction model may be used to predict the probability that a first log block has a performance problem based on historical log blocks associated with the same functional page and a reference fluctuation trend of at least one performance indicator.

[0092] In any embodiment of the present disclosure, the following steps A to B may be used to predict the probability that the first log block has a performance problem:

[0093] Step A: Obtain reference performance data associated with the same function page; wherein the reference performance data is generated by the server based on log blocks associated with the same function page sent by multiple clients.

[0094] Exemplarily, the reference performance data includes, but is not limited to: the average indicator value of each performance indicator associated with the same function page, such as the average page rendering time, the average request time, etc.; the acceptable indicator threshold or indicator range corresponding to each performance indicator associated with the same function page; performance data for different time periods (such as weekdays, weekends, morning and evening peak hours, etc.); performance data related to different user portraits, for example, performance data for different device types, network environments, regions, etc.

[0095] Step B: predicting the probability of a performance problem existing in the first log block based on the reference performance data, the historical log block and the reference fluctuation trend of at least one performance indicator.

[0096] As an example, reference performance data associated with the same function page, a reference fluctuation trend of at least one performance indicator, a historical log block, and a first log block can be simultaneously input into a performance prediction model for performance prediction to obtain the probability of a performance problem existing in the first log block output by the performance prediction model.

[0097] Therefore, by integrating the log blocks generated during the interaction between other users and the same function page, the historical log blocks and the first log block generated during the interaction between the current user and the same function page, and combining the reference fluctuation trends of various performance indicators closely related to the same function page, it is possible to predict whether there is a performance problem in the first log block. This can comprehensively consider the fluctuation trends of log data and performance indicators in multiple dimensions, thereby being able to more comprehensively and deeply evaluate the performance status of the first log block. Compared with relying solely on a single data source, it can effectively avoid possible one-sidedness and significantly improve the accuracy and reliability of the prediction results.

[0098] Step S205, determine whether the probability is higher than the probability threshold, if so, execute step S206, if not, execute step S207.

[0099] In the embodiment of the present disclosure, it can be determined whether the above probability is higher than a set probability threshold (such as 0.8, 0.9, etc.). If so, it is determined that the first log block has a performance problem with obvious degradation. At this time, step S206 can be further executed. If not, it is determined that the first log block does not have a performance problem with obvious degradation. At this time, step S207 can be further executed.

[0100] It should be noted that step S206 and step S207 are two parallel implementation methods. In actual application, only one needs to be executed.

[0101] Step S206: determine that there is a performance problem in the first log block, and use a first processing strategy adapted to the performance problem to process the first log block.

[0102] In an embodiment of the present disclosure, when the probability that the first log block has a performance problem is higher than a probability threshold, it can be determined that the first log block has a performance problem, that is, the first log block is a degraded performance log. At this time, a first processing strategy adapted to the performance problem can be further adopted to process the first log block.

[0103] Step S207: Determine that there is no performance problem with the first log block, and continue to read other log blocks from the log database.

[0104] In the embodiment of the present disclosure, when the probability that the first log block has a performance problem is not higher than the probability threshold, it can be determined that the first log block does not have a performance problem, that is, the first log block is not a degraded performance log. At this time, other log blocks can continue to be read from the log database, that is, return to execute step S201 and subsequent steps.

[0105] The log block processing method of the embodiment of the present disclosure can more accurately capture the unique behavior pattern and performance requirements of a single user and more accurately predict the performance problem in the first log block by focusing on the interaction history of a single user with the same functional page. In addition, by combining the reference fluctuation trend of each performance indicator associated with the same functional page, the potential pattern and trend of the performance problem can be identified, providing richer context information for performance prediction, thereby improving the prediction accuracy.

[0106] In order to clearly explain how the first processing strategy adapted to the performance issue is adopted in the above embodiment to process the first log block, the present disclosure further proposes a log block processing method.

[0107] Figure 3 This is a flow chart of the log block processing method provided in the third embodiment of the present disclosure.

[0108] like Figure 3 As shown, the log block processing method may include the following steps S301 to S305:

[0109] Step S301 : reading at least one first log block associated with the same function page in the target application from a log database associated with the target application.

[0110] Step S302: In response to the log type to which the first log block belongs being a performance log, query a reference fluctuation trend of at least one performance indicator associated with the same function page.

[0111] Step S303: predict whether there is a performance problem in the first log block based on a reference fluctuation trend of at least one performance indicator.

[0112] It should be noted that the explanation of steps S301 to S303 can be found in the relevant description in any embodiment of the present disclosure and will not be repeated here.

[0113] Step S304: If it exists, write the first log block into the first reporting queue adapted to the performance problem.

[0114] The reporting priority of the first reporting queue is lower than the set priority, that is, the first reporting queue can be a low-priority reporting queue.

[0115] In the embodiment of the present disclosure, when there is a performance problem in the first log block, the first log block may be written into a first reporting queue adapted to the performance problem.

[0116] Step S305: In an idle state, the log blocks belonging to the performance log in the first reporting queue are reported to the server.

[0117] In the embodiment of the present disclosure, the log blocks belonging to the performance log (i.e., the log blocks with performance degradation) in the first reporting queue can be reported to the server when the execution subject is in an idle state. Accordingly, when the server receives the log blocks belonging to the performance log, it can calculate the target indicator value according to the log blocks belonging to the performance log, wherein the target indicator value is used to indicate the proportion of log blocks with a degradation degree higher than the set degree, and to determine whether the target indicator value is higher than the corresponding indicator threshold. If not, it indicates that the degraded performance log does not affect the normal use of the user. At this time, no processing is required. If so, it indicates that the degraded performance log has affected the normal use of the user. At this time, the server can issue the first alarm.

[0118] Exemplarily, the server can query the relevant personnel (such as R&D personnel, product managers, etc.) responsible for the corresponding function page, and send an alarm message to the relevant personnel so that the relevant personnel can promptly locate and repair the problem of the corresponding function page in the target application, wherein the alarm message may carry a log block of performance degradation, or carry key performance information in the log block of performance degradation.

[0119] In any embodiment of the present disclosure, the server may use the following steps C to E to calculate the target indicator value:

[0120] Step C: for any log block belonging to the performance log, query the reference log block reported by the client that reported the log block within the target time period.

[0121] The reference log block and the function page to which any log block belongs are the same, that is, the reference log block and the any log block contain log records generated during the interaction between the same user and the same function page.

[0122] Among them, the duration of the target period is pre-set, for example, the duration of the target period can be 1 day, wherein the starting time of the target period is determined according to the current time, for example, the starting time of the target period can be the early morning of the previous day, at this time, the target period can be the previous day.

[0123] Step D: Calculate the degradation degree of any log block according to the reference log block.

[0124] As an example, the index values ​​of each performance index can be extracted from the reference log block and the any log block respectively. For each performance index, the change between the index value in the any log block and the index value in the reference log block is calculated, and it is determined whether the change is higher than the degradation threshold corresponding to the performance index. If so, it is determined that the performance index has degraded. At this time, the degradation degree of the any log block can be calculated according to the change of each performance index that has degraded. For example, the degradation degree of the any log block can be calculated by a simple proportional operation or weighted average method.

[0125] As another example, a more complex algorithm or a prediction model based on machine learning may be used to calculate the degree of degradation of any log block based on the reference log block, which is not limited in the embodiments of the present disclosure.

[0126] Step E: Calculate the target index value according to the degradation degree of each log block belonging to the performance log.

[0127] That is, the target log block can be determined from the log blocks belonging to the performance log according to the degree of degradation of each log block belonging to the performance log, wherein the degree of degradation of the target log block is higher than the set degree, and the proportion of the target log block is used as the target indicator value, that is, the target indicator value = the number of target log blocks / the total number of log blocks belonging to the performance log.

[0128] Therefore, the degradation degree of each performance-degraded log block is calculated through the interaction history of the same user with the same function page, and the target indicator value for triggering the alarm mechanism is calculated based on the degradation degree, which can improve the rationality, reliability and effectiveness of the target indicator value calculation.

[0129] As an application scenario, during the development phase of the target application, developers can use the log block processing method provided in the present disclosure to analyze the application logs during the testing phase, promptly discover and fix potential operating problems, and ensure the quality of the target application before it goes online.

[0130] As another application scenario, during the operation stage of the target application, for the target application that has been launched, the operator can continuously monitor the user's usage through the log block processing method provided by the present invention, promptly discover and solve user problems, and improve user satisfaction and retention rate.

[0131] The log block processing method of the disclosed embodiment allows the execution subject to upload the log blocks with performance degradation when idle, thus avoiding the occupation of precious network resources and computing resources when busy, thereby ensuring the smooth operation of the target application. The server can receive and analyze the performance degradation log blocks reported from each client in real time. By calculating the degree of degradation of each log block, the server can more accurately assess the severity of the performance problem, thereby taking appropriate measures, such as sending an alarm notification, etc., and the server will issue the first alarm when it detects that the proportion of log blocks with a higher degree of degradation reaches the indicator threshold, which can quickly attract the attention of relevant personnel, allowing them to immediately locate the source of the problem, and then efficiently troubleshoot and repair performance problems, minimizing the impact on users.

[0132] In order to clearly illustrate any embodiment of the present disclosure, the present disclosure also proposes a log block processing method.

[0133] Figure 4 This is a flow chart of the log block processing method provided in the fourth embodiment of the present disclosure.

[0134] like Figure 4 As shown, the log block processing method may include the following steps S401 to S402:

[0135] Step S401 : reading at least one first log block associated with the same function page in the target application from a log database associated with the target application.

[0136] It should be noted that the explanation of step S401 can refer to the relevant description in any embodiment of the present disclosure and will not be repeated here.

[0137] In any embodiment of the present disclosure, the first log block includes all log records generated by the same functional page during the use period, and the first log block includes but is not limited to at least one of the following information:

[0138] The first item is the page ID of the same function page.

[0139] The second item is the page source of the same function page.

[0140] For example, assuming that a user clicks a control on function page A and enters function page B, the page source of function page B is used to indicate function page A.

[0141] The third item is the first time consumption of the same function page (i.e., the page opening time consumption); wherein, the first time consumption is determined based on the rendering completion time of the same function page and the touch time of the first target control used to open the same function page.

[0142] Among them, the first target control is used to open the same function page mentioned above.

[0143] Exemplarily, the rendering completion time may be determined by following steps E to F:

[0144] Step E: When the user's touch operation on the first target control is detected and the same function page is rendered and displayed, starting from the root view (Root View) of the view hierarchy of the same function page, recursively traverse to the sub view (Sub View) of the last layer in the view hierarchy.

[0145] Among them, touch operations include but are not limited to: click operation, long press operation, sliding operation, etc.

[0146] As an example, when monitoring the user's touch operation on the first target control and rendering and displaying the same function page, you can start from the root view (Root View) of the view hierarchy managed by the ViewController (view controller) of the same function page, and recursively traverse to all levels of sub views (Sub View) in the view hierarchy until the sub view of the last layer.

[0147] Among them, ViewController is responsible for managing the life cycle and layout of one or more views of the UI (User Interface). ViewController is not only responsible for the display of the view, but also handles user interaction, data binding and other logic.

[0148] The root view is the top-level view in the view hierarchy managed by the ViewController. As a container, it contains all other view elements on the page. That is, as the basis of the page layout, the root view contains all the subviews on the page (such as buttons, text boxes, pictures, etc.), and the root view is responsible for the layout and arrangement of its subviews, ensuring that they are displayed correctly according to the design requirements, and is responsible for passing user interaction events (such as clicks, slides, etc.) to the corresponding subviews or ViewController for processing.

[0149] The sub view is relative to the root view, and refers to the view element added to the root view or other views. The sub view can be any type of view, such as a button, text box, label, image view, etc.

[0150] Step F: In response to the width and height of the display attributes (such as the frame attribute) of all traversed views being greater than a set threshold, it is determined that the rendering of the same functional page is completed, and the rendering completion time is recorded.

[0151] The threshold value is set as a preset value. It should be understood that the threshold value is set as a relatively small value. For example, the threshold value may be set to 0.

[0152] Therefore, when the width (width) and height (height) in the display properties (such as frame properties) of all views in the view hierarchy managed by the ViewController of a certain functional page are greater than the set threshold, it indicates that all views have been rendered to the expected size. At this time, it can be determined that the rendering of the functional page is completed, and the rendering completion time of the functional page is recorded, which can improve the accuracy of determining the rendering completion time and avoid calculating the rendering completion time of the page when the page content is not fully displayed, thereby causing inaccurate calculation.

[0153] The fourth item is the opening time of the same function page during the usage cycle.

[0154] The fifth item is the second time consumed between each network request sent by the same function page during the usage period and the receipt of the network response.

[0155] Item 6: In response to the network response being an error response, record the response parameters in the network response and the request parameters in the network request.

[0156] Item 7: In response to a crash or a flash back of the same function page, the crash stack information recorded.

[0157] For example, when the target application or the same function page mentioned above crashes or quits due to some reason (such as memory leak, program error, etc.), the crash stack information can be automatically recorded, where the crash stack information includes the code call sequence that caused the crash. For developers, this is an important basis for locating and solving problems.

[0158] Item 8: In response to a change in a heating signal of an electronic device displaying the same function page, heating change information is recorded.

[0159] Among them, the electronic device can be any device with computing capabilities, such as a personal computer, a mobile terminal, etc. The mobile terminal can be, for example, a mobile phone, a tablet computer, a personal digital assistant, a wearable device, and other hardware devices with various operating systems, touch screens and / or display screens.

[0160] It should be noted that the operation of the target application may cause the electronic device to heat up. If the executor detects a change in the heating signal of the electronic device (such as the temperature rises to a certain temperature threshold), the change will be recorded, which will help developers evaluate the performance of the target application and its impact on the electronic device.

[0161] Item 9: A control identifier of a second target control in the same function page; wherein the second target control includes a control that monitors a touch event. Taking the touch event as an example of a click event, the second target control includes a control clicked by a user in the same function page.

[0162] Therefore, when a user uses a certain function in the target application, different log records are recorded at different times, which helps the developer of the target application to quickly locate the source of the problem when performance problems or other problems occur. This not only improves the efficiency of troubleshooting, but also helps developers to fix problems efficiently, thereby minimizing the impact on users.

[0163] Step S402: In response to the log type to which the first log block belongs being an error log, a second processing strategy adapted to the error log is adopted to process the first log block.

[0164] The second processing strategy is different from the first processing strategy.

[0165] In the embodiment of the present disclosure, when the log type to which the first log block belongs is an error log, a second processing strategy adapted to the error log can be used to process the first log block, so as to timely handle the error problem in the first log block, avoid the error problem from continuing to expand and causing negative impact on the target application, thereby improving the user experience.

[0166] In any embodiment of the present disclosure, the second processing strategy may include the following steps G and H:

[0167] Step G: In response to the log type to which the first log block belongs being an error log, the first log block is written into a second reporting queue adapted to the error log.

[0168] Among them, the reporting priority of the second reporting queue is higher than the set priority, that is, the second reporting queue can be a high-priority reporting queue.

[0169] Step H: Report the log block belonging to the error log in the second reporting queue to the server.

[0170] In an embodiment of the present disclosure, the execution entity may report the log blocks belonging to the error log in the second reporting queue to the server in real time. Accordingly, when the server receives the log blocks belonging to the error log, it may cluster the log blocks belonging to the error log to obtain at least one cluster, wherein the basis for clustering may include the interface and error code of the network request, the crashed page and the crash stack information, etc. For example, the log blocks containing the network request-interface and the error code are clustered into the same cluster, the log blocks containing the crash stack information are clustered into the same cluster, etc. Afterwards, it can be determined whether there is a target cluster in each cluster, wherein the number of log blocks in the target cluster is higher than the set number. If the target cluster does not exist, no processing may be performed. If the target cluster exists, a second alarm is issued.

[0171] Exemplarily, the server can query relevant personnel (such as R&D personnel, product managers, etc.) who are responsible for the corresponding function page or the error category in the target cluster, and send alarm information to the relevant personnel so that the relevant personnel can promptly locate and repair the problem of the corresponding function page in the target application, wherein the alarm information can carry the log block in the target cluster, or carry the key error information in the target cluster.

[0172] Therefore, by reporting error logs to the server in real time and performing cluster analysis, recurring problems or specific types of errors can be quickly identified, helping developers quickly locate the source of the problem. In addition, clustered error logs reduce redundant information, allowing developers to focus more on key error information, thereby improving the efficiency of troubleshooting. Efficient error log processing and troubleshooting mechanisms can shorten the time it takes to fix problems, thereby minimizing the impact on users and improving user experience.

[0173] The log block processing method of the embodiment of the present disclosure can perform targeted processing on the specific content and type of the error log, thereby more effectively solving the problem and reducing the possibility of false positives and false negatives. Moreover, by adopting a targeted processing strategy, it can ensure that the error log is accurately and reliably processed, thereby improving the stability and reliability of the entire system.

[0174] In order to clearly illustrate any embodiment of the present disclosure, the present disclosure also proposes a log block processing method.

[0175] Figure 5 This is a flowchart of the log block processing method provided in Embodiment 5 of the present disclosure.

[0176] like Figure 5 As shown, the timing of writing a log block in a log database includes the following steps S501 to S505:

[0177] Step S501, in response to collecting a new log record associated with a target application, query whether there is a first record queue associated with a first function page to which the new log record belongs, if so, execute step S502, if not, execute steps S503 to S505.

[0178] Among them, the newly added log records are collected during the use period of the first function page.

[0179] The first record queue is used to record various log records associated with the first functional page, that is, the first record queue is used to record various log records collected during the use period of the first functional page.

[0180] It should be noted that step S502 and steps S503 to S505 are two parallel implementation methods. In actual application, only one needs to be executed.

[0181] Step S502: write the newly added log record into the first record queue.

[0182] In an embodiment of the present disclosure, when a new log record associated with a target application is collected, it is possible to query whether there is a page record queue associated with the first function page to which the new log record belongs, which is referred to as the first record queue in the present disclosure. If so, it is determined that the first function page to which the new log record belongs is an old function page that has been opened before. At this time, the new log record can be directly written into the existing page record queue (i.e., the first record queue) associated with the first function page.

[0183] Step S503: Create a second record queue associated with the first function page, and write the newly added log record into the second record queue.

[0184] In an embodiment of the present disclosure, when new log records associated with the target application are collected, it is possible to query whether there is a page record queue associated with the first function page to which the new log record belongs, which is referred to as the first record queue in the present disclosure. If not, it is determined that the first function page to which the new log record belongs is the most recently opened function page. At this time, a new record queue can be established for the first function page, which is referred to as the second record queue in the present disclosure, and the new log record can be written into the second record queue.

[0185] Step S504: combine the third record queues into a second log block; wherein the second function page to which each log record in the third record queue belongs is different from the first function page.

[0186] In an embodiment of the present disclosure, when a user opens a new function page (i.e., the first function page), the third record queue associated with the previously opened old function page (recorded as the second function page in the present disclosure) can be combined into a log block, recorded as the second log block in the present disclosure, wherein the second log block includes each log record generated during the use cycle of the second function page.

[0187] Step S505: write the second log block into the log database.

[0188] In an embodiment of the present disclosure, the second log block can be written to the log database. Exemplarily, the second log block can be written to the log database when the log database is in an idle state (i.e., a non-read-write state, a non-access state) to avoid data dirty reading.

[0189] In any embodiment of the present disclosure, the following steps may be used to write the second log block into the log database:

[0190] Step a: Query whether the log database is in access state (ie, read-write state). If so, execute steps b to d; if not, execute steps e to h, or execute steps i to k.

[0191] It should be noted that steps b to d, steps e to h, and steps i to k are implemented in parallel. In actual application, only one needs to be executed.

[0192] Step b: When the log database is not in access state, that is, the log database is in idle state, query whether there is an overdue log block with a storage time longer than the set time in the log database. If yes, execute step c; if not, execute step d.

[0193] The set duration can be dynamically or individually configured according to actual application requirements or business needs.

[0194] It should be noted that step c and step d are two parallel implementation methods. In actual application, only one needs to be executed.

[0195] Step c: If there is an expired log block in the log database, the expired log block is deleted and the second log block is written into the log database.

[0196] Exemplarily, the expired log block at the head of the log database may be deleted, and the second log block may be written to the tail of the log database.

[0197] Step d: If there is no overdue log block in the log database, directly write the second log block into the log database.

[0198] Therefore, cleaning and writing operations when the log database is not in an access state can ensure that these operations will not conflict with other concurrent activities in the log database, thereby optimizing resource usage, which helps reduce system overhead and improve overall performance. In addition, deleting expired log blocks and writing new log blocks when the log database is idle can avoid data competition with other concurrent operations, thereby maintaining data consistency in the log database and improving system stability and responsiveness.

[0199] Step e: When the log database is in access status, try to obtain the read-write lock of the log database.

[0200] Step f: When the read-write lock is successfully acquired, the log database is locked based on the read-write lock.

[0201] Step g: Delete the expired log block in the log database, and write the second log block into the log database.

[0202] In the present disclosure, if there are overdue log blocks in the log database whose storage time is longer than the set time, the overdue log blocks in the log database can be deleted and the second log block can be written into the log database; if there are no overdue log blocks in the log database, the second log block can be directly written into the log database.

[0203] Step h: In response to the second log block being written, the log database is unlocked and the read-write lock is released.

[0204] Therefore, by acquiring the read-write lock, it can be ensured that there is no interference from other concurrent operations when reading and writing to the log database, which avoids data competition and potential data inconsistency problems. The locking mechanism ensures that the operations of deleting expired log blocks and writing new log blocks are atomic, which ensures that the log database will not be in an intermediate state during the operation, thereby maintaining the integrity of the data, maintaining the consistency, integrity, concurrency performance and reliability of the system.

[0205] Step i: When the log database is in an access state, the state of the log database is periodically queried.

[0206] The cycle duration can be dynamically or individually configured according to actual application requirements or business requirements. For example, the cycle duration can be 1 second.

[0207] Step j: in response to the state of the log database being restored to an idle state, the expired log blocks in the log database are deleted.

[0208] In the present disclosure, when the state of the log database is restored to an idle state, it is possible to query the log database whether there are overdue log blocks with a storage period longer than the set period. If so, the overdue log blocks in the log database can be deleted. If not, the second log block can be directly written into the log database.

[0209] Step k: Write the second log block into the log database.

[0210] Therefore, by periodically querying the state of the log database and performing cleanup and write operations when it returns to an idle state, it can be ensured that these operations will not conflict with other concurrent activities of the log database, which helps to optimize resource usage and avoid unnecessary waiting or blocking. Deleting expired log blocks and writing new log blocks when the log database is in an idle state can ensure that these operations are performed without other interference, which helps maintain data consistency in the log database and avoid data loss or inconsistency.

[0211] The log block processing method of the disclosed embodiment can effectively form a complete log block with all log records generated during the use cycle of the old function page that has been opened before when a new function page is opened, thereby improving the effectiveness and accuracy of subsequent log block reading.

[0212] In any of the embodiments of the present disclosure, application logs can be deeply analyzed through machine learning or deep learning technology to automatically sniff and identify potential usage problems, thereby helping developers to locate and fix problems in a timely manner and improve user experience.

[0213] As an example, taking the target application as a mobile application, the technical solution provided by the present disclosure mainly includes the following two parts: mobile user travel log recording and concatenation, and problem sniffing and alarm based on machine learning.

[0214] The first part is the logging and concatenation of mobile user activities.

[0215] Among them, the user's travel log includes the pages visited by the user, the operations performed, the operation duration, and the errors that occurred when the user used the application. The errors include network errors, application crashes, system API (Application Programming Interface) errors, etc.

[0216] Log concatenation refers to segmenting and organizing the log records generated by users and forming complete user operations according to time, so as to quickly analyze the causes of user problems.

[0217] As an example, the implementation principle of user trace log recording and concatenation can be as follows: Figure 6 As shown, when a user uses a certain function, corresponding log records can be recorded at different times, mainly including the following log records:

[0218] 601. When a function page is opened, the function page and the time taken to open the function page are recorded;

[0219] 602. When the function needs to send a network request, record the time taken from sending the network request to receiving the network response. If an error (err) occurs in the network response, record the err, and record the request parameters and response parameters.

[0220] 603. When clicking / sliding the UI, if a crash / flashback occurs, record the crash stack information; if the electronic device has a heating signal change, record the heating change information; record the control (such as a button) clicked by the user. If the user clicks the control and enters the next function page, it is considered that the declaration cycle of this function page has ended, and record the click source page of the next function page.

[0221] 604. The log records generated in 601, 602 and 603 may be connected in series.

[0222] 605. Write the concatenated log blocks into the user's log database.

[0223] For example, the log concatenation process can be as follows: Figure 7 As shown, it mainly includes the following steps:

[0224] Step 701: When a new log record is generated, first determine whether the function page to which the log record belongs is the latest opened page. If so, execute steps 702 to 703; if not, execute step 704 and subsequent steps.

[0225] Step 702: If the function page to which the log record belongs is the most recently opened page, a new record queue (referred to as the second record queue in this disclosure) is established.

[0226] Step 703: Write the log record into the second record queue, such as adding the log record to the first entry in the second record queue.

[0227] Step 704 : Determine whether there is a page record queue (referred to as the first record queue in the present disclosure) associated with the functional page to which the log record belongs. If so, execute step 705 ; if not, execute step 703 .

[0228] Step 705: If the first record queue exists, the log record is added to the tail of the first record queue, that is, the log records are written in chronological order from oldest to newest.

[0229] Step 706: If it is determined that the function page to which the log record belongs is the latest opened page, the record queue of the old function page opened previously is further combined into a log block (using the function page as the attribute key and the log record list in the record queue as the attribute value).

[0230] Step 707: Determine whether the log database is in an access state (ie, a read-write state). If so, execute step 708; if not, execute step 709.

[0231] Step 708: Wait first to avoid dirty reading, and periodically query the state of the log database or use a read-write lock until the log database is restored to an idle state.

[0232] Step 709: If the log database is restored to an idle state, the expired log block is queried from the log database. For example, the head log block can be read from the log database, and it can be determined whether the storage time of the head log block has expired. If so, the head log block is used as an expired log block.

[0233] Step 710: Delete expired log blocks.

[0234] Step 711: until there is no overdue log block, write a new log block to the end of the log database.

[0235] It should be noted that before the application is killed and before the application enters the background, it is necessary to force the log to be written to improve the integrity of the log records in the log block.

[0236] The second part is problem sniffing and alarm based on machine learning. Its implementation principle is as follows Figure 8 shown.

[0237] Among them, problem sniffing: identifying problems that occur during the operation of the application.

[0238] Among them, problem alarm: report problems that occur during the operation of the application directly to the relevant responsible personnel.

[0239] Among them, problem sniffing includes the following steps:

[0240] Step 801: Read log blocks from a log database.

[0241] Step 802: Determine the log type to which the read log block belongs.

[0242] Step 803: Determine whether the log type is an identification log or (or) an error log or (or) a performance log. If the log type is an identification log, return to execute step 801. If the log type is a performance log, execute steps 804 to 806. If the log type is an error log, then the log type is an error log, and execute step 806.

[0243] Figure 8 The log types in the mainly include the following three categories: identification log, error log, performance log, among which, identification log: has no special meaning, used to identify log blocks, user actions; error log: indicates that an error occurs when the application is running, directly marking that there is a problem with the function; performance log: includes the above-mentioned request time, page opening time, heat changes, etc. These problems will not be directly reported by users, but will affect the user experience.

[0244] Step 804: If the log type is a performance log, the model may be used to determine the performance quality of the log block belonging to the performance log.

[0245] Exemplarily, an LSTM model can be used to determine whether there is a performance problem with the currently read log block, wherein the LSTM model predicts whether the current performance data is degraded performance data through the currently read log block (i.e., current performance data), the previous same performance data (historical log block), the subsequent same performance data, and the same page performance data (determined by the server based on log blocks uploaded by other clients, recorded as reference performance data in this disclosure). If so, it is determined that there is a performance problem with the current performance data.

[0246] Among them, during the model training stage, abnormal data in the performance data (extra large values, trend high points) can be used as the result set.

[0247] Step 805: Determine whether the output result of the model indicates that the log block has a degraded performance problem. If so, execute step 806; if not, do nothing.

[0248] Step 806: If the log type is an error log, then the log block belonging to the error log is directly marked, or if the log block has a performance problem, the log block is marked as degraded.

[0249] Among them, for problem sniffing: Figure 8 In the case that there is no task in the write queue, a separate child thread reads the log blocks in the log database one by one and determines the log type to which the log block belongs, instead of reading and writing at the same time, to prevent excessive CPU usage.

[0250] The problem alarm includes the following steps:

[0251] Step 807: Determine whether the log block is an error log or a degraded performance log.

[0252] Step 808: For the error log, add it to a high-priority reporting queue.

[0253] Step 809: Report the log blocks in the high-priority reporting queue directly to the server in a timely manner.

[0254] Step 810: For the degraded performance log, add it to the low priority reporting queue. That is, for the performance log, because it does not need to be processed immediately, it can be reported to the server together when it is idle (such as when the application enters the background or the application is killed), reducing the QPS (Queries-per-second) request volume.

[0255] Step 811: In an idle state, the log blocks in the low-priority reporting queue are reported to the server.

[0256] Step 812: On the server side, the reported log block is stored.

[0257] Step 813: The server side retrieves the stored log blocks periodically.

[0258] Step 814: cluster the log blocks belonging to the error log by problem clustering (such as network request-interface and error code, crash through page and crash stack) to obtain various clusters.

[0259] Step 815: Determine whether there is a cluster whose number of log blocks exceeds a certain threshold.

[0260] Step 816: If the number of log blocks contained in a certain cluster exceeds a certain threshold, the responsible person is found through code commit.

[0261] Step 817: Finally, the corresponding log block is sent to the responsible person via email or SMS.

[0262] Step 818: Compare the log block belonging to the performance log (referred to as current performance data) with the old performance data (such as the log block uploaded the day before).

[0263] Step 819: Determine whether the current performance data is significantly degraded compared to the old performance data. If the current performance data is significantly degraded compared to the old performance data, execute steps 817 to 818, that is, report the key information in the current performance data to the responsible person and carry the corresponding log block.

[0264] As an example, taking the target application as a mobile application, the application scenario of the present disclosure can be as follows: Fig. 9As shown in the figure, the target application is accessed through SDK on the mobile end and called on the business layer. The SDK is responsible for log storage, concatenation, identification and reporting, and the business side is responsible for log generation. Log statistics and problem alarms are implemented on the server side.

[0265] In summary, through problem alarm, the problem response and processing time can be advanced to prevent the continuous expansion of user problems and negative impact on the application; through problem sniffing, the efficiency of locating problems can be improved and the time-consuming manual query can be reduced; through centralized monitoring, it not only covers request problems and direct application experience problems such as crashes and overheating, but also monitors the smoothness problems of application runtime, realizing comprehensive monitoring. It not only monitors crashes, overheating, request errors, etc., but also covers performance indicators that can reflect the application operation process, realizing automatic monitoring, automatic alarm, and rapid response and location of problem causes.

[0266] With the above Figures 1 to 9 Corresponding to the log block processing method provided in the embodiment, the present disclosure also provides a log block processing device. Figures 1 to 9 The log block processing method provided in the embodiment corresponds to the log block processing method, so the implementation of the log block processing method is also applicable to the log block processing device provided in the embodiment of the present disclosure, and will not be described in detail in the embodiment of the present disclosure.

[0267] Fig.10 This is a structural diagram of the log block processing device provided in Example 6 of the present disclosure.

[0268] like Fig.10 As shown, the log block processing device 1000 may include: a reading module 1010 , a first query module 1020 , a prediction module 1030 and a first processing module 1040 .

[0269] The reading module 1010 is used to read at least one first log block associated with the same function page in the target application from a log database associated with the target application;

[0270] A first query module 1020, configured to query a reference fluctuation trend of at least one performance indicator associated with the same function page in response to the log type to which the first log block belongs being a performance log;

[0271] A prediction module 1030, configured to predict whether there is a performance problem in the first log block based on a reference fluctuation trend of at least one performance indicator;

[0272] The first processing module 1040 is configured to process the first log block using a first processing strategy adapted to the performance issue if the problem exists.

[0273] In a possible implementation of the embodiment of the present disclosure, the prediction module 1030 is used to: obtain historical log blocks associated with the same functional page; predict the probability that a first log block has a performance problem based on the historical log blocks and a reference fluctuation trend of at least one performance indicator; when the probability is higher than a probability threshold, determine that the first log block has a performance problem; when the probability is not higher than the probability threshold, determine that the first log block does not have a performance problem.

[0274] In a possible implementation of the embodiment of the present disclosure, the prediction module 1030 is used to: obtain reference performance data associated with the same function page; wherein the reference performance data is generated by the server based on log blocks associated with the same function page sent by multiple clients; and predict the probability of a performance problem existing in the first log block based on the reference performance data, historical log blocks and a reference fluctuation trend of at least one performance indicator.

[0275] In a possible implementation of the embodiment of the present disclosure, the first processing module 1040 is used to: if present, write the first log block into a first reporting queue adapted to the performance problem; wherein the reporting priority of the first reporting queue is lower than the set priority; in an idle state, report the log block belonging to the performance log in the first reporting queue to the server;

[0276] Among them, the log block belonging to the performance log is used by the server to calculate the target indicator value and issue a first alarm when the target indicator value is higher than the indicator threshold; wherein the target indicator value is used to indicate the proportion of log blocks whose degradation degree is higher than the set degree.

[0277] In a possible implementation of the embodiment of the present disclosure, the target indicator value is calculated using the following modules:

[0278] A second query module is used to query, for any log block belonging to the performance log, a reference log block reported by a client that reports any log block within a target period; wherein the reference log block is the same as the function page to which any log block belongs;

[0279] A determination module, used to determine the degradation degree of any log block according to the reference log block;

[0280] The calculation module is used to calculate the target indicator value according to the degradation degree of each log block belonging to the performance log.

[0281] In a possible implementation of the embodiment of the present disclosure, the log block processing device 1000 further includes:

[0282] The second processing module is configured to process the first log block by adopting a second processing strategy adapted to the error log in response to the log type to which the first log block belongs being an error log.

[0283] In a possible implementation of the embodiment of the present disclosure, the second processing module is configured to:

[0284] In response to the log type to which the first log block belongs being an error log, writing the first log block into a second reporting queue adapted to the error log; wherein the reporting priority of the second reporting queue is higher than the set priority;

[0285] Report the log block belonging to the error log in the second reporting queue to the server;

[0286] The log blocks belonging to the error log are clustered on the server side to obtain at least one cluster, and when there is a target cluster in each cluster, a second alarm is issued according to the target cluster; wherein the number of log blocks in the target cluster is higher than the set number.

[0287] In a possible implementation of the embodiment of the present disclosure, the first log block includes all log records generated by the same function page during the usage cycle, and the first log block includes at least one of the following information: a page identifier of the same function page; a page source of the same function page; a first time consumption of the same function page; wherein the first time consumption is determined based on the rendering completion time of the same function page and the touch time of the first target control used to open the same function page; the opening duration of the same function page during the usage cycle; the second time consumption between each network request sent by the same function page during the usage cycle and the receipt of the network response; in response to the network response being an error response, the response parameters in the network response and the request parameters in the network request are recorded; in response to the same function page crashing or flashing back, the crash stack information is recorded; in response to the heating signal of the electronic device displaying the same function page changing, the heating change information is recorded; the control identifier of the second target control in the same function page; wherein the second target control includes the control that monitors the touch event.

[0288] In a possible implementation of the embodiment of the present disclosure, the rendering completion time is determined by using the following modules:

[0289] A traversal module, used for, in the process of detecting a touch operation on the first target control and rendering and displaying the same function page, starting from the root view of the view hierarchy of the same function page, recursively traversing to the last layer of subviews in the view hierarchy;

[0290] The recording module is used to determine that the rendering of the same functional page is completed in response to the width and height in the display properties of all traversed views being greater than a set threshold, and record the rendering completion time.

[0291] In a possible implementation of the embodiment of the present disclosure, the log blocks in the log database are written using the following modules:

[0292] A third query module is used for querying whether there is a first record queue associated with the first function page to which the new log record belongs in response to the collection of the new log record associated with the target application;

[0293] a writing module, configured to write the newly added log record into the first record queue if yes, and to create a second record queue associated with the first function page if no, and write the newly added log record into the second record queue;

[0294] A combining module, used for combining the third record queue into a second log block; wherein the second function page to which each log record in the third record queue belongs is different from the first function page;

[0295] The writing module is further used to write the second log block into the log database.

[0296] In a possible implementation of the embodiment of the present disclosure, the writing module is used to: query whether the log database is in an access state; if the log database is not in an access state, query whether there is an overdue log block in the log database with a storage time longer than a set time; if so, delete the overdue log block and write the second log block to the log database.

[0297] In a possible implementation of the embodiment of the present disclosure, the write module is also used to: when the log database is in an access state, attempt to obtain the read-write lock of the log database; when the read-write lock is successfully obtained, lock the log database based on the read-write lock; delete the expired log block in the log database, and write the second log block to the log database; in response to the completion of writing the second log block, unlock the log database and release the read-write lock.

[0298] In a possible implementation of the embodiment of the present disclosure, the write module is also used to: when the log database is in an access state, periodically query the state of the log database; in response to the state of the log database being restored to an idle state, delete the expired log blocks in the log database; and write the second log block to the log database.

[0299] The log block processing device of the embodiment of the present disclosure predicts whether there is a performance problem in the first log block associated with the same function page by using the reference fluctuation trend of at least one performance indicator associated with the same function page, which can improve the automation, timeliness and accuracy of performance problem discovery and can proactively predict potential performance problems. Once there is a performance problem in the first log block, the first processing strategy adapted to the performance problem is used to process the first log block, so that the performance problem in the first log block can be processed in a timely manner to avoid the performance problem from continuing to expand and causing a negative impact on the target application, thereby improving the user experience. In addition, by connecting or integrating all log records of the same function page within the usage cycle into one log block, it is possible to quickly lock the source of the problem when a performance problem occurs in a certain log block, thereby accelerating the repair process of the target application.

[0300] In order to implement the above embodiments, the present disclosure also provides an electronic device, which may include at least one processor; and a memory communicatively connected to the at least one processor; wherein the memory stores instructions executable by the at least one processor, and the instructions are executed by the at least one processor so that the at least one processor can execute the log block processing method proposed in any of the above embodiments of the present disclosure.

[0301] In order to implement the above embodiments, the present disclosure further provides a non-transitory computer-readable storage medium storing computer instructions, wherein the computer instructions are used to enable a computer to execute the log block processing method proposed in any of the above embodiments of the present disclosure.

[0302] In order to implement the above embodiments, the present disclosure further provides a computer program product, which includes a computer program. When the computer program is executed by a processor, the log block processing method proposed in any of the above embodiments of the present disclosure is implemented.

[0303] According to an embodiment of the present disclosure, the present disclosure also provides an electronic device, a readable storage medium and a computer program product.

[0304] Fig.11 A schematic block diagram of an example electronic device that can be used to implement embodiments of the present disclosure is shown.

[0305] Among them, the electronic device may include the server and the client in the above-mentioned embodiment. The electronic device is intended to represent various forms of digital computers, such as laptop computers, desktop computers, workbenches, personal digital assistants, servers, blade servers, mainframe computers, and other suitable computers. The electronic device can also represent various forms of mobile devices, such as personal digital processing, cellular phones, smart phones, wearable devices and other similar computing devices. The components shown herein, their connections and relationships, and their functions are only examples and are not intended to limit the implementation of the present disclosure described and / or required herein.

[0306] like Fig.11 As shown, the electronic device 1100 includes a computing unit 1101, which can perform various appropriate actions and processes according to a computer program stored in a ROM (Read-Only Memory) 1102 or a computer program loaded from a storage unit 1107 to a RAM (Random Access Memory) 1103. In the RAM 1103, various programs and data required for the operation of the device 1100 can also be stored. The computing unit 1101, the ROM 1102, and the RAM 1103 are connected to each other via a bus 1104. An I / O (Input / Output) interface 1105 is also connected to the bus 1104.

[0307] A number of components in the device 1100 are connected to the I / O interface 1105, including: an input unit 1106, such as a keyboard, a mouse, etc.; an output unit 1107, such as various types of displays, speakers, etc.; a storage unit 1108, such as a disk, an optical disk, etc.; and a communication unit 1109, such as a network card, a modem, a wireless communication transceiver, etc. The communication unit 1109 allows the device 1100 to exchange information / data with other devices through a computer network such as the Internet and / or various telecommunication networks.

[0308] The computing unit 1101 may be a variety of general and / or special processing components with processing and computing capabilities. Some examples of the computing unit 1101 include, but are not limited to, a CPU (Central Processing Unit), a GPU (Graphic Processing Units), various dedicated AI (Artificial Intelligence) computing chips, various computing units running machine learning model algorithms, a DSP (Digital Signal Processor), and any appropriate processor, controller, microcontroller, etc. The computing unit 1101 performs the various methods and processes described above, such as the above-described log block processing method. For example, in some embodiments, the above-described log block processing method may be implemented as a computer software program, which is tangibly contained in a machine-readable medium, such as a storage unit 1108. In some embodiments, part or all of the computer program may be loaded and / or installed on the device 1100 via the ROM 1102 and / or the communication unit 1109. When the computer program is loaded into the RAM 1103 and executed by the computing unit 1101, one or more steps of the log block processing method described above may be performed. Alternatively, in other embodiments, the computing unit 1101 may be configured to execute the above-mentioned log block processing method in any other appropriate manner (for example, by means of firmware).

[0309] Various embodiments of the systems and techniques described above herein may be implemented in digital electronic circuit systems, integrated circuit systems, FPGAs (Field Programmable Gate Arrays), ASICs (Application-Specific Integrated Circuits), ASSPs (Application Specific Standard Products), SOCs (System On Chips), CPLDs (Complex Programmable Logic Devices), computer hardware, firmware, software, and / or combinations thereof. These various embodiments may include: being implemented in one or more computer programs that may be executed and / or interpreted on a programmable system including at least one programmable processor that may be a dedicated or general-purpose programmable processor that may receive data and instructions from a storage system, at least one input device, and at least one output device, and transmit data and instructions to the storage system, the at least one input device, and the at least one output device.

[0310] The program code for implementing the method of the present disclosure may be written in any combination of one or more programming languages. These program codes may be provided to a processor or controller of a general-purpose computer, a special-purpose computer, or other programmable data processing device, so that the program code, when executed by the processor or controller, enables the functions / operations specified in the flow chart and / or block diagram to be implemented. The program code may be executed entirely on the machine, partially on the machine, partially on the machine and partially on a remote machine as a stand-alone software package, or entirely on a remote machine or server.

[0311] In the context of the present disclosure, a machine-readable medium may be a tangible medium that may contain or store a program for use by or in conjunction with an instruction execution system, device, or equipment. A machine-readable medium may be a machine-readable signal medium or a machine-readable storage medium. A machine-readable medium may include, but is not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, device, or device, or any suitable combination of the foregoing. More specific examples of machine-readable storage media may include electrical connections based on one or more lines, portable computer disks, hard disks, RAM, ROM, EPROM (Electrically Programmable Read-Only-Memory) or flash memory, optical fiber, CD-ROM (Compact Disc Read-Only Memory), optical storage devices, magnetic storage devices, or any suitable combination of the foregoing.

[0312] To provide interaction with a user, the systems and techniques described herein can be implemented on a computer having: a display device (e.g., a CRT (Cathode-Ray Tube) or LCD (Liquid Crystal Display) monitor) for displaying information to the user; and a keyboard and pointing device (e.g., a mouse or trackball) through which the user can provide input to the computer. Other types of devices can also be used to provide interaction with the user; for example, the feedback provided to the user can be any form of sensory feedback (e.g., visual feedback, auditory feedback, or tactile feedback); and input from the user can be received in any form (including acoustic input, voice input, or tactile input).

[0313] The systems and techniques described herein may be implemented in a computing system that includes backend components (e.g., as a data server), or a computing system that includes middleware components (e.g., an application server), or a computing system that includes frontend components (e.g., a user computer with a graphical user interface or a web browser through which a user can interact with implementations of the systems and techniques described herein), or a computing system that includes any combination of such backend components, middleware components, or frontend components. The components of the system may be interconnected by any form or medium of digital data communication (e.g., a communication network). Examples of communication networks include: LAN (Local Area Network), WAN (Wide Area Network), the Internet, and blockchain networks.

[0314] A computer system may include a client and a server. The client and the server are generally remote from each other and usually interact through a communication network. The relationship between the client and the server is generated by computer programs running on the corresponding computers and having a client-server relationship with each other. The server may be a cloud server, also known as a cloud computing server or a cloud host, which is a host product in the cloud computing service system to solve the defects of difficult management and weak business scalability in traditional physical hosts and VPS services (Virtual Private Server). The server may also be a server of a distributed system, or a server combined with a blockchain.

[0315] It should be noted that artificial intelligence is a discipline that studies how computers can simulate certain human thought processes and intelligent behaviors (such as learning, reasoning, thinking, planning, etc.), and includes both hardware-level and software-level technologies. Artificial intelligence hardware technologies generally include technologies such as sensors, dedicated artificial intelligence chips, cloud computing, distributed storage, and big data processing; artificial intelligence software technologies mainly include computer vision technology, speech recognition technology, natural language processing technology, as well as machine learning / deep learning, big data processing technology, knowledge graph technology, and other major directions.

[0316] According to the technical solution of the embodiment of the present disclosure, by adopting the reference fluctuation trend of at least one performance indicator associated with the same function page to predict whether the first log block associated with the same function page has a performance problem, the automation, timeliness and accuracy of performance problem discovery can be improved, and potential performance problems can be predicted prospectively. Once there is a performance problem in the first log block, the first processing strategy adapted to the performance problem is adopted to process the first log block, so that the performance problem in the first log block can be processed in a timely manner, and the performance problem can be prevented from continuing to expand and having a negative impact on the target application, thereby improving the user experience. In addition, by connecting or integrating all log records of the same function page within the usage cycle into one log block, it is possible to quickly lock the source of the problem when a performance problem occurs in a certain log block, thereby accelerating the repair process of the target application.

[0317] It should be understood that the various forms of processes shown above can be used to reorder, add or delete steps. For example, the steps recorded in this disclosure can be executed in parallel, sequentially or in different orders, as long as the desired results of the technical solutions disclosed in this disclosure can be achieved, and this document does not limit this.

[0318] The above specific implementations do not constitute a limitation on the protection scope of the present disclosure. It should be understood by those skilled in the art that various modifications, combinations, sub-combinations and substitutions can be made according to design requirements and other factors. Any modification, equivalent substitution and improvement made within the spirit and principle of the present disclosure shall be included in the protection scope of the present disclosure.

Claims

1. A log block processing method, characterized in that: The method comprises: Reading, from a log database associated with a target application, at least one first log block associated with a same function page in the target application; In response to the log type to which the first log block belongs being a performance log, querying a reference fluctuation trend of at least one performance indicator associated with the same function page; Based on the reference fluctuation trend of the at least one performance indicator, predicting whether the first log block has a performance problem; If so, a first processing strategy adapted to the performance issue is adopted to process the first log block.

2. The method according to claim 1, wherein: The predicting whether the first log block has a performance problem based on the reference fluctuation trend of the at least one performance indicator includes: Obtaining a history log block associated with the same function page; Predicting a probability that the first log block has a performance problem according to the historical log block and a reference fluctuation trend of the at least one performance indicator; When the probability is higher than a probability threshold, determining that the first log block has a performance problem; When the probability is not higher than the probability threshold, it is determined that the first log block has no performance problem.

3. The method according to claim 2, wherein: The predicting, based on the historical log block and the reference fluctuation trend of the at least one performance indicator, the probability that the first log block has a performance problem includes: Acquire reference performance data associated with the same function page; wherein the reference performance data is generated by the server according to log blocks associated with the same function page sent by multiple clients; The probability that the first log block has a performance problem is predicted based on the reference performance data, the historical log block and the reference fluctuation trend of the at least one performance indicator.

4. The method according to claim 1, wherein: If the first log block exists, the first processing strategy adapted to the performance problem is adopted to process the first log block, including: If so, writing the first log block into a first reporting queue adapted to the performance problem; wherein the reporting priority of the first reporting queue is lower than the set priority; In an idle state, reporting the log blocks belonging to the performance log in the first reporting queue to the server; Among them, the log block belonging to the performance log is used by the server to calculate the target indicator value, and to issue a first alarm when the target indicator value is higher than the indicator threshold; wherein the target indicator value is used to indicate the proportion of log blocks whose degradation degree is higher than the set degree.

5. The method according to claim 4, wherein: The target index value is calculated by the following steps: For any log block belonging to the performance log, query a reference log block reported by a client that reports the any log block within a target period; wherein the reference log block is the same as the function page to which the any log block belongs; Determining the degradation degree of any one of the log blocks according to the reference log block; The target indicator value is calculated according to the degradation degree of each log block belonging to the performance log.

6. The method according to claim 1, wherein: The method further comprises: In response to the log type to which the first log block belongs being an error log, the first log block is processed using a second processing strategy adapted to the error log.

7. The method according to claim 6, wherein: In response to the log type to which the first log block belongs being an error log, using a second processing strategy adapted to the error log to process the first log block includes: In response to the log type to which the first log block belongs being an error log, writing the first log block into a second reporting queue adapted to the error log; wherein the reporting priority of the second reporting queue is higher than the set priority; Reporting the log block belonging to the error log in the second reporting queue to the server; The log blocks belonging to the error log are used for clustering by the server to obtain at least one cluster, and when there is a target cluster in each of the clusters, a second alarm is issued according to the target cluster; The number of log blocks in the target cluster is higher than a set number.

8. The method according to any one of claims 1 to 7, wherein: The first log block includes all log records generated by the same functional page during the use period, and the first log block includes at least one of the following information: The page identifier of the same functional page; The page source of the same function page; The first time consumption of the same function page; wherein the first time consumption is determined according to the rendering completion time of the same function page and the touch time of the first target control for opening the same function page; The duration of time the same functional page is open during the usage period; a second time consumption between each network request sent by the same functional page within the usage period and the receipt of a network response; In response to the network response being an error response, recording a response parameter in the network response and a request parameter in the network request; In response to a crash or a flashback of the same function page, the recorded crash stack information; In response to a change in a heating signal of the electronic device displaying the same function page, the recorded heating change information; The control identifier of the second target control in the same function page; wherein the second target control includes a control that monitors a touch event.

9. The method according to claim 8, wherein: The rendering completion time is determined by the following steps: In the process of detecting the touch operation on the first target control and rendering and displaying the same function page, starting from the root view of the view hierarchy structure of the same function page, recursively traversing to the last layer of subviews in the view hierarchy structure; In response to the width and height in the display attributes of all traversed views being greater than a set threshold, it is determined that the rendering of the same functional page is completed, and the rendering completion time is recorded.

10. The method according to any one of claims 1 to 7, wherein: The timing of writing log blocks in the log database includes: In response to collecting a new log record associated with the target application, querying whether there is a first record queue associated with a first function page to which the new log record belongs; If yes, write the newly added log record into the first record queue; if no, create a second record queue associated with the first function page, and write the newly added log record into the second record queue; Combining the third record queue into a second log block; wherein the second function page to which each log record in the third record queue belongs is different from the first function page; The second log block is written into the log database.

11. The method according to claim 10, wherein: The step of writing the second log block into the log database comprises: Query whether the log database is in access status; When the log database is not in the access state, querying the log database whether there is an overdue log block whose storage time is longer than the set time; If it exists, the expired log block is deleted, and the second log block is written into the log database.

12. The method according to claim 11, wherein: After querying whether the log database is in an access state, the method further includes: When the log database is in the access state, attempting to obtain a read-write lock of the log database; In the case where the read-write lock is successfully acquired, locking the log database based on the read-write lock; Deleting the expired log block in the log database, and writing the second log block into the log database; In response to the second log block being written completely, the log database is unlocked and the read-write lock is released.

13. The method according to claim 11, wherein: After querying whether the log database is in an access state, the method further includes: When the log database is in the access state, periodically querying the state of the log database; In response to the state of the log database being restored to an idle state, deleting the expired log blocks in the log database; The second log block is written into the log database.

14. A log block processing device, characterized in that: The device comprises: A reading module, configured to read at least one first log block associated with the same function page in the target application from a log database associated with the target application; A first query module, configured to query a reference fluctuation trend of at least one performance indicator associated with the same function page in response to the log type to which the first log block belongs being a performance log; A prediction module, configured to predict whether the first log block has a performance problem based on a reference fluctuation trend of the at least one performance indicator; The first processing module is used to process the first log block by adopting a first processing strategy adapted to the performance problem, if any.

15. The device according to claim 14, wherein: The prediction module is used to: Obtaining a history log block associated with the same function page; Predicting a probability that the first log block has a performance problem according to the historical log block and a reference fluctuation trend of the at least one performance indicator; When the probability is higher than a probability threshold, determining that the first log block has a performance problem; When the probability is not higher than the probability threshold, it is determined that the first log block has no performance problem.

16. The device according to claim 15, wherein: The prediction module is used to: Acquire reference performance data associated with the same function page; wherein the reference performance data is generated by the server according to log blocks associated with the same function page sent by multiple clients; The probability that the first log block has a performance problem is predicted based on the reference performance data, the historical log block and the reference fluctuation trend of the at least one performance indicator.

17. The device according to claim 14, wherein: The first processing module is used to: If so, writing the first log block into a first reporting queue adapted to the performance problem; wherein the reporting priority of the first reporting queue is lower than the set priority; In an idle state, reporting the log blocks belonging to the performance log in the first reporting queue to the server; Among them, the log block belonging to the performance log is used by the server to calculate the target indicator value, and to issue a first alarm when the target indicator value is higher than the indicator threshold; wherein the target indicator value is used to indicate the proportion of log blocks whose degradation degree is higher than the set degree.

18. The device according to claim 17, wherein: The target indicator value is calculated using the following modules: A second query module is used to query, for any log block belonging to the performance log, a reference log block reported by a client that reports the any log block within a target period; wherein the reference log block is the same as the function page to which the any log block belongs; A determination module, configured to determine the degradation degree of any log block according to the reference log block; The calculation module is used to calculate the target indicator value according to the degradation degree of each log block belonging to the performance log.

19. The device according to claim 14, wherein: The device also includes: The second processing module is configured to process the first log block by adopting a second processing strategy adapted to the error log in response to the log type to which the first log block belongs being an error log.

20. The device according to claim 19, wherein The second processing module is used to: In response to the log type to which the first log block belongs being an error log, writing the first log block into a second reporting queue adapted to the error log; wherein the reporting priority of the second reporting queue is higher than the set priority; Reporting the log block belonging to the error log in the second reporting queue to the server; The log blocks belonging to the error log are used for clustering by the server to obtain at least one cluster, and when there is a target cluster in each of the clusters, a second alarm is issued according to the target cluster; The number of log blocks in the target cluster is higher than a set number.

21. The device according to any one of claims 14 to 20, wherein: The first log block includes all log records generated by the same functional page during the use period, and the first log block includes at least one of the following information: The page identifier of the same functional page; The page source of the same function page; The first time consumption of the same function page; wherein the first time consumption is determined according to the rendering completion time of the same function page and the touch time of the first target control for opening the same function page; The duration of time the same functional page is open during the usage period; a second time consumption between each network request sent by the same functional page within the usage period and the receipt of a network response; In response to the network response being an error response, recording a response parameter in the network response and a request parameter in the network request; In response to a crash or a flashback of the same function page, the recorded crash stack information; In response to a change in a heating signal of the electronic device displaying the same function page, the recorded heating change information; The control identifier of the second target control in the same function page; wherein the second target control includes a control that monitors a touch event.

22. The device according to claim 21, wherein The rendering completion time is determined by the following modules: A traversal module, configured to, in the process of detecting a touch operation on the first target control and rendering and displaying the same function page, recursively traverse from the root view of the view hierarchy of the same function page to the subview of the last layer in the view hierarchy; The recording module is used to determine that the rendering of the same functional page is completed in response to the width and height in the display properties of all traversed views being greater than a set threshold, and record the rendering completion time.

23. The device according to any one of claims 14 to 20, wherein: The log blocks in the log database are written using the following modules: A third query module is used for querying whether there is a first record queue associated with the first function page to which the new log record belongs in response to the collection of the new log record associated with the target application; a writing module, configured to, if yes, write the newly added log record into the first record queue; if no, create a second record queue associated with the first function page, and write the newly added log record into the second record queue; a combining module, used for combining the third record queue into a second log block; wherein the second function page to which each log record in the third record queue belongs is different from the first function page; The writing module is further used to write the second log block into the log database.

24. The device according to claim 23, wherein: The writing module is used for: Query whether the log database is in access status; When the log database is not in the access state, querying the log database whether there is an overdue log block whose storage time is longer than the set time; If it exists, the expired log block is deleted, and the second log block is written into the log database.

25. The device according to claim 24, wherein: The writing module is further used for: When the log database is in the access state, attempting to obtain a read-write lock of the log database; In the case where the read-write lock is successfully acquired, locking the log database based on the read-write lock; Deleting the expired log block in the log database, and writing the second log block into the log database; In response to the second log block being written completely, the log database is unlocked and the read-write lock is released.

26. The device according to claim 24, wherein: The writing module is further used for: When the log database is in the access state, periodically querying the state of the log database; In response to the state of the log database being restored to an idle state, deleting the expired log blocks in the log database; The second log block is written into the log database.

27. An electronic device comprising: at least one processor; as well as a memory communicatively connected to the at least one processor; wherein, The memory stores instructions that can be executed by the at least one processor, and the instructions are executed by the at least one processor to enable the at least one processor to execute the log block processing method according to any one of claims 1 to 13.

28. A non-transitory computer-readable storage medium storing computer instructions, wherein: The computer instructions are used to enable the computer to execute the log block processing method according to any one of claims 1-13.

29. A computer program product, comprising a computer program, wherein when the computer program is executed by a processor, the computer program implements the steps of the log block processing method according to any one of claims 1 to 13.

Images