Log processing method, system and device and storage medium

Abstract

The invention discloses a log processing method, system and device and a storage medium. The method comprises the following steps: accessing a software development kit in a target application; and collecting log information of the target application through the software development kit, and reporting the log information to a server, so that the server integrates and processes the log information, and the server displays an integration processing result through a front-end page. According to the embodiment of the invention, the log information is collected in real time through the software development kit, so that the timeliness and integrity of log collection are improved, and the program running performance is improved. The method can be widely applied to the technical field of computers.

Description

Technical Field

[0001] This application relates to the field of computer technology, and in particular to a log processing method, system, device, and storage medium. Background Art

[0002] With the development of technology, people's lives are becoming increasingly closely connected to electronic products. Subsequently, various client application programs have emerged like bamboo shoots after a spring rain. When an exception occurs during program operation, it is usually located through the running log. Therefore, timely obtaining and analyzing the log information of client application programs is crucial for the maintenance of client application programs.

[0003] In the related art, for some client application programs, comprehensive log information cannot be obtained in real time. For example, for some client application programs related to games, the logs are written to a local file for storage, and then reported to a specified file server when the program exits to obtain the log information. This solution has the following problems: The log upload is not timely enough, and the program operation status cannot be monitored and adjusted through the log information, which affects the program operation performance and user experience. In some other embodiments, such as web applications without file writing permissions, users often refresh or even close the page when encountering an exception during use, and it is easy to lose the abnormal context at that time. And the front-end monitoring system can only monitor a small segment of logs when an abnormal use case occurs, and cannot obtain all the log information in real time; it cannot detect program problems in time, affecting the operation performance. Summary of the Invention

[0004] The purpose of this application is to solve at least to some extent one of the technical problems existing in the prior art.

[0005] To this end, the purpose of this application is to provide an efficient log processing method, system, device, and storage medium.

[0006] To achieve the above technical purpose, on the one hand, an embodiment of this application provides a log processing method, which includes the following steps: Connect a software development kit to the target application; collect the log information of the target application through the software development kit, and report the log information to the server, so that the server integrates and processes the log information, and the server displays the integrated processing result through the front-end page. The embodiment of this application collects log information in real time through the software development kit, which is beneficial to improving the timeliness and integrity of log collection, and then improving the program operation performance.

[0007] In some embodiments, for the log processing method of the embodiment of this application, the target application is a web application, and the collecting the log information of the target application through the software development kit and reporting the log information to the server includes:

[0008] Collect the log information through the software development kit and format the log information.

[0009] Temporarily store the log information in a database through a worker process, and report the log information to the server based on configuration information; the configuration information is the setting of the storage space and reporting parameters for the log.

[0010] In some embodiments, for the log processing method of the embodiments of the present application, the method further includes:

[0011] If the application thread monitors that the target application starts to run, start a monitoring thread.

[0012] Receive the log information through the monitoring thread and report the log information to the server through another thread.

[0013] In some embodiments, reporting the log information to the server includes:

[0014] Obtain the cumulative duration; the cumulative duration is the duration elapsed since the last log information report.

[0015] If the cumulative duration is greater than or equal to a preset duration, report the log information to the server through another thread and return to the step of obtaining the cumulative duration.

[0016] Alternatively, if the number of current log information entries is greater than or equal to a preset number, report the log information to the server through another thread.

[0017] In some embodiments, the method further includes:

[0018] When the target application is applied to the client, initialize the log reporting interface through the software development kit.

[0019] Report the basic information of the client to the server through the log reporting interface, so that the server can integrate and process the log information according to the basic information.

[0020] In some embodiments, reporting the log information to the server includes:

[0021] If log information is obtained through a log output function, call back to the log reporting interface.

[0022] Process and report the log information through a callback function.

[0023] In some embodiments, reporting the log information to the server includes:

[0024] Add the preset log information to the log information; the preset log information includes the log scenario information, user information, and operating system information;

[0025] Combine the log information into a preset format and report it to the server through the first set interface.

[0026] On the other hand, an embodiment of the present application provides a log processing method applied to a server. The method includes the following steps:

[0027] Receive the log information collected and reported by the target application through the software development kit;

[0028] Integrate and process the log information, and send the integration processing result to the front-end page so that the front-end page can display the integration processing result.

[0029] In some embodiments, the method further includes:

[0030] Append the log information to a preset file address through an appendable object in the object storage service;

[0031] Determine the storage duration of the log information according to the log level, and perform clearing or permanent preservation processing on the log information according to the storage duration.

[0032] In some embodiments, the integrating and processing the log information includes:

[0033] Integrate and process the log information according to the hash value corresponding to the log stack of the log information;

[0034] And / or, integrate and process the log information according to the scenario information;

[0035] And / or, integrate and process the log information according to the device information;

[0036] And / or, integrate and process the log information according to the alarm information.

[0037] In some embodiments, in an embodiment of the present application, the method further includes:

[0038] Display the running log interface, receive a trigger operation on the first control in the running log interface, and display the daily statistics area;

[0039] Receive an edit operation or a selection operation on the preset information in the daily statistics area, and display the integrated log information; the preset information is an integration rule for integrating the log information.

[0040] In some embodiments, in one embodiment of the present application, the method further includes:

[0041] Receiving a triggering operation on a second control in the operation log interface and displaying a configuration setting area;

[0042] Receiving an editing operation on the alarm information in the configuration setting area, and if the log information includes the alarm information, sending the log information to a target object.

[0043] On the other hand, an embodiment of the present application provides a log processing system, including:

[0044] A first module for:

[0045] Integrating a software development kit in a target application;

[0046] Collecting log information of the target application through the software development kit, and reporting the log information to a server, so that the server integrates and processes the log information, and enables the server to display the integrated processing result through a front-end page;

[0047] And / or, a second module for:

[0048] Receiving log information collected and reported by a target application through a software development kit;

[0049] Integrating and processing the log information, and sending the integrated processing result to a front-end page, so that the front-end page displays the integrated processing result.

[0050] On the other hand, an embodiment of the present application provides a log processing device, including:

[0051] At least one processor;

[0052] At least one memory for storing at least one program;

[0053] When the at least one program is executed by the at least one processor, the at least one processor implements the above-mentioned log processing method.

[0054] On the other hand, an embodiment of the present application provides a storage medium, in which a processor-executable program is stored, and the processor-executable program is used to implement the above-mentioned log processing method when executed by a processor.

[0055] An embodiment of the present application provides a log processing method, system, device, and storage medium. The method includes the following steps: Connect a software development kit to a target application; collect log information of the target application through the software development kit and report the log information to a server, so that the server integrates and processes the log information, and the server displays the integrated processing result through a front-end page. By collecting log information in real time through the software development kit, the embodiment of the present application is beneficial to improving the timeliness and integrity of log collection, and further improving the program running performance. BRIEF DESCRIPTION OF THE DRAWINGS

[0056] In order to more clearly illustrate the technical solutions in the embodiments of the present application or the prior art, the following introduces the accompanying drawings related to the technical solutions in the embodiments of the present application or the prior art. It should be understood that the accompanying drawings below are only for conveniently and clearly presenting some embodiments of the technical solutions in the present application. For those skilled in the art, without creative efforts, other drawings can also be obtained based on these drawings.

[0057] Figure 1 FIG. is a schematic diagram of an application scenario of an embodiment of the log processing method provided by the present application;

[0058] Figure 2 FIG. is a schematic flowchart of an embodiment of the log processing method provided by the present application;

[0059] Figure 3 FIG. is a schematic flowchart of another embodiment of the log processing method provided by the present application;

[0060] Figure 4 FIG. is a schematic diagram showing an embodiment of the running log interface provided by the embodiment of the present application;

[0061] Figure 5 FIG. is a schematic diagram showing an embodiment of the display area of a single log message provided by the embodiment of the present application;

[0062] Figure 6 FIG. is a schematic diagram showing an embodiment of the real-time log area provided by the embodiment of the present application;

[0063] Figure 7 FIG. is a schematic diagram showing an embodiment of the message reminder after configuration settings provided by the embodiment of the present application;

[0064] Figure 8 FIG. is a schematic diagram showing an embodiment of the query details area provided by the embodiment of the present application;

[0065] Figure 9 FIG. is a schematic diagram showing an embodiment of the device information viewing area provided by the embodiment of the present application;

[0066] Figure 10 Schematic structural diagram of an embodiment of the log processing system provided for this application;

[0067] Figure 11 Schematic structural diagram of an embodiment of the log processing device provided for this application. Detailed implementation manners

[0068] The embodiments of this application will be described in detail below. The examples of the embodiments are shown in the accompanying drawings, where the same or similar reference numerals denote the same or similar elements or elements with the same or similar functions from beginning to end. The embodiments described below with reference to the accompanying drawings are exemplary and are only used to explain this application and should not be construed as a limitation to this application. For the step numbers in the following embodiments, they are only set for the convenience of explanation and illustration, and no limitation is imposed on the order between the steps. The execution order of each step in the embodiments can be adaptively adjusted according to the understanding of those skilled in the art.

[0069] Before elaborating on the embodiments of this application in detail, necessary explanations will be given to the technical terms or feature terms that may be involved in the embodiments of this application:

[0070] Software Development Kit (SDK): A collection of development tools for creating application software for specific software packages, software frameworks, hardware platforms, operating systems, etc. Generally speaking, the SDK is the SDK used by the application programs under the development platform. From a functional perspective, it can help developers develop application programs for specific platforms, software frameworks, or systems. For example, the Android SDK provides various tools required for developing Android applications, including compilers, debuggers, and Android system-related APIs (Application Programming Interfaces). These APIs allow developers to conveniently use the functions of the Android system, such as calling the camera and obtaining the geographical location. The SDK also includes a documentation part, which is used to explain the usage methods of the tools and the functional details of the APIs, guiding developers to develop software correctly and efficiently.

[0071] Unity: A widely used cross - platform game development engine. It supports 2D and 3D game development. In terms of 3D games, it can create high - quality graphics effects, such as realistic lighting, material textures, etc. For example, many large - scale 3D open - world games utilize the powerful functions of Unity to build beautiful game scenes. From a cross - platform perspective, it allows developers to easily publish games to multiple platforms, including Windows, Mac, iOS, Android, console platforms, etc., greatly expanding the game's audience. Unity has a rich resource store where developers can obtain various resources such as plugins, models, materials, etc., reducing development time. At the same time, it provides a simple and easy - to - use visual editor. Through operations such as dragging and dropping components, even people without profound programming experience can start their game creation journey.

[0072] When an exception occurs during game operation, it is usually only possible to locate the problem through the running log. However, currently in the market, to obtain the running log, one has to write the log to a local file for saving and then report it to a specified file server when the game exits. This solution has certain drawbacks. For example, the log reporting is not timely enough as it can only be uploaded when the user exits the game. Otherwise, data loss may occur. The size of the reported log is uncontrollable. If the user plays for a long time, a large log may cause abnormal file upload or affect game performance. The log cannot be statistically analyzed, and the required log content can only be extracted through secondary processing of the transmitted log file using tools.

[0073] In response to this, an embodiment of this application proposes a log processing method. An SDK (Software Development Kit) is integrated into the client program; the SDK is used to collect log information and report the log information to the server for integration and display; wherein, the log information is the log generated by the program. By using the SDK to collect log information in real - time, the timeliness of log collection is improved; and the log information is integrated and displayed to improve the efficiency of log processing.

[0074] Figure 1FIG. 0 shows a schematic diagram of an application scenario of a log processing method provided by an embodiment of the present application. In this application scenario, it includes at least one terminal device 201 and a server 202. The terminal device can be the client in the present application. An object can enter a target application through the terminal device for experience, and log information is generated during this process. In some embodiments, the target application can be a game program. A software development kit is integrated into the game program of the terminal device to collect log information during the game in real time. And the log information is reported to the server, and the log information is integrated and summarized. The processing result is displayed through a front-end page for relevant personnel to view and process. In this application scenario, the terminal device can be any electronic product that can perform human-computer interaction in one or more ways such as a keyboard, a touchpad, a touch screen, a remote control, voice interaction, or a handwriting device. The electronic product can process log information through a web page or application programs (Apps) such as game applications and social applications installed therein. For example, the terminal device can be a personal computer (PC), a mobile phone, a smart phone, a personal digital assistant (PDA), a wearable device, a pocket PC (PPC), a tablet computer, etc. It can be understood that in this application scenario, the server can be an independent server, or a server cluster composed of several servers, or a cloud computing service center; the form of the server is not limited to the forms described in the above examples. In this application scenario, the log processing method proposed in the present application can also be implemented based on the server. A software platform for log processing provided by the application embodiment is installed on the server. The server obtains the log information of the client through the integrated software development kit, and performs multi-angle data integration processing on the log information to obtain an integration result; and the integration result is displayed through a front-end page. The application embodiments of the present application do not limit the specific application scenario, and the above Figure 1 application scenario is only for illustrative purposes.

[0075] As Figure 2 shown, an embodiment of the present application provides a log processing method, which can be applied to the terminal device 201 or the server 202 in the above Figure 1 to implement, or can be executed on any device or equipment with data processing capabilities, such as a smart phone. Referring to Figure 2 , the method specifically includes but is not limited to steps S100 - S200:

[0076] S100: Integrate a software development kit into the target application.

[0077] In the embodiments of the present application, the software development kit is used to collect log information in real time. In some embodiments, the target application in the present application can be various types of application programs, including but not limited to game application programs (game APPs), office application programs, and social application programs. The target application in the present application can also be various types of (mobile) web applications. The present application does not limit the type of the target application.

[0078] In some examples, for a target application that is a client game program installed on a player's device (such as a computer or a mobile phone), it is used to process the player's input, be responsible for rendering the game scene, interact with the server for data, etc., to maintain the normal operation of the game and an excellent player experience. In the present application, by integrating the software development kit into the game program on the client side, it is convenient to collect log information in real time and report the log information to the server, so as to alleviate the problems of untimely reporting and uncontrollable size of log information in the related art.

[0079] In some embodiments, the process of integrating the SDK into the game program generally can be as follows: Preliminary preparation; clarify requirements and select the SDK: According to the functional requirements of the game, select a suitable SDK provider; register and obtain information. Integration implementation: Download and integrate the SDK: Download the corresponding SDK package from the provider's official website or the developer platform, and according to the provided documentation, add the SDK file to the game project and configure relevant dependencies. For example, in some integrated development environments of the Android system, the SDK file can be placed in a preset directory or added through relevant build tools; Configure parameters and initialize: Configure relevant parameters according to the documentation, etc. Function implementation and testing: Implement relevant functions: For example, for the log function in the present application, relevant interfaces need to be created in the game, and then the SDK interface is called to send data. Process the result and callback: After the operation is completed, receive the sending result through the callback interface and verify its integrity and correctness. Testing and debugging: Conduct unit testing, integration testing, and sandbox testing to ensure the stability and security of relevant functions. Go live and maintain. Of course, the above process is an exemplary example, and the present application does not limit the specific process of integrating the software development kit into the game program. Those skilled in the art can adjust this process according to factors such as the specific type of the game and the type of the client.

[0080] S200: Collect the log information of the target application through the software development kit, and report the log information to the server, so that the server can integrate and process the log information, and enable the server to display the integrated processing result through the front-end page.

[0081] In some possible embodiments, the server in the present application is used to integrate and process log information, and display the integration and processing results through a front-end page, so as to improve the efficiency of log processing. Exemplarily, for game applications, game logs record various events during the game operation. Specifically, the log information may include: system information: including game version number, running platform, such as PC, mobile (Android or other related systems), etc.; the start and end times of the game, used to record a complete running cycle of the game. Player behavior, game events, scene switching records, network information, error information, etc. Through the game's log information, problems can be discovered and solved in a timely manner when the game runs abnormally, so that the game program can operate normally and provide a good gaming experience for game players.

[0082] Referring to Figure 3 As shown, the present application collects log information through a software development kit, and then reports the collected log information to the server. The server classifies and organizes the log information to facilitate subsequent search and comparison of the log information, improve the log processing efficiency, and further improve the system operation stability. It should be noted that the present application does not limit the specific manner of integrating and displaying log information, and those skilled in the art can set it according to actual needs. The embodiment of the present application collects log information in real time through a software development kit, which is beneficial to improving the timeliness of log collection; and integrates and displays the log information to improve the efficiency of log processing.

[0083] Optionally, in an embodiment of the present application, the target application is a web application. Collecting the log information of the target application through a software development kit and reporting the log information to the server includes:

[0084] Collect log information through a software development kit and format the log information;

[0085] Through a worker process, temporarily store the log information in a database, and based on the configuration information, report the log information to the server; the configuration information is the setting of the storage space and reporting parameters of the log.

[0086] It is understandable that for some web applications with strong interactivity (i.e., web apps), users may stay on the page for a long time to perform various operations. Affected by possible errors (i.e., bugs) in the web application, the user device environment, network fluctuations, etc., there may be functional abnormalities at a certain moment. When developers need to troubleshoot such problems, it will be rather troublesome, and they need to analyze the user's behavior trajectory, and even the parameters, responses, and interface request records of each step of the behavior. However, unlike application programs (i.e., APPs) or desktop software, web applications do not persistently store detailed logs in the running directory. Web applications do not have an installation directory and do not have file writing permissions. When users encounter abnormalities during use, they often refresh or even close the page, and it is very easy to lose the abnormal context at that time. If the running logs can be uploaded to the server in real time or with low latency during operation, then once a user reports a problem, the log context at that time can be directly retrieved, which is very helpful for assisting in locating abnormal problems on the user side.

[0087] Of course, there are many monitoring systems on the front end, such as the Application Real-time Monitoring Service (ARMS) and self-developed monitoring systems. These monitoring systems can not only monitor the key indicators of page performance and interface performance, but also monitor abnormal use cases of the page (i.e., abnormal cases), and they are also relatively perfect in terms of visualization and project management. These monitoring systems can basically meet the needs of regular web applications, but they all lack complete user-side logs. Only in the case of abnormal cases will the client-side logs be brought. However, due to the limitation of the data length uploaded for a single abnormal case, these logs are only a part of the data closest to the occurrence of the abnormality. That is to say, these systems only have a short segment of logs when an abnormal case occurs, which is not suitable for the web applications with strong interactivity mentioned above. First of all, the web applications with strong interactivity have a large amount of logs and long user stay times. They not only need the logs when the abnormality occurs, but also need the logs for a long time before that.

[0088] Therefore, for web applications, the log processing method proposed in this application can also be used to access the software development kit, and the software development kit is used to collect log information to obtain the log information of the web application in real time.

[0089] Exemplarily, the web - end logs are output and normalized. On the one hand, the web - end provides a log - printing SDK to standardize standard information such as the log - printing format, log level, and the module to which it belongs. On the other hand, the web - end intercepts all non - SDK - printed logs on the page by rewriting the log - output methods of the console class (such as log, warn, error of the console class), and then standard - serializes them into a string format, marking the log level and the log - printing time. This can ensure that all log outputs on the page are standard - formatted and recorded with time information.

[0090] The embodiment of the present application also provides web - end log caching. After the logs are collected, they should be uploaded as soon as possible. However, it is limited that the log - output frequency and quantity on the web - end are unstable. In addition, the log upload cannot affect the normal network requests of the page functions. Therefore, the collected logs can be cached. This solution uses an index database (such as the indexDB database) that is widely supported on the web - end. It can persistently store information to prevent data loss when the user closes the page. In addition, this database storage is also particularly convenient for retrieval and query processing.

[0091] In addition, the configuration information in the present application can be the maximum supported number of stored logs. For example, each single log can be at most 8 kb. If it exceeds, it will be intercepted. At most, the last 10,000 logs are stored. When it exceeds, the old logs are deleted in a rotation form to prevent the log cache from occupying too much disk space. Of course, these limit parameters are configurable, and appropriate thresholds can be set according to the actual situation of the project. The present application does not make a detailed limitation on the size of the cached log space.

[0092] Based on performance considerations, the operations of local log caching and subsequent uploads that occupy CPU resources and network resources should not affect the normal functions of users. Therefore, in this solution, the log caching and upload are designed to be executed in a separate worker process. The main process of the user interface is only responsible for sending the logs to the worker process by sending a message (postMessage). The worker process is responsible for the read - write operations of the database and the log - upload operation.

[0093] In terms of upload - speed control, the present application also adjusts through configuration information, specifying the size of each log upload. For example, at most 400 KB can be uploaded at a time, and the time consumed for each upload is controlled within 200 ms. Then, according to the current accumulation of cached logs and the actual time consumed for each upload, these information are used to dynamically adjust the size of each log upload amount (i.e., the configuration information).

[0094] For the logs of emergency upload and post - event upload, when the user gives an active feedback due to an anomaly, or the program detects a functional anomaly, or the user is about to close the page, there is an urgent need to upload the logs that have been generated at present as soon as possible for subsequent analysis. Otherwise, once the user closes the page and the subsequent upload logic cannot be executed, the latest key log information in the staging queue cannot be obtained. Therefore, this application provides an emergency upload instruction. This instruction can be called based on its own logic or immediately called when monitoring that the page is about to close (such as through the beforeunload event). After the call, the currently staged log information is immediately uploaded (that is, this upload is not restricted by the size and time limits mentioned above). It should be noted that the unrestrictedness mentioned here with respect to the size and time limits mentioned above means that for performance considerations, log upload should not affect the normal use of the network by the user's page, so the size and duration of each upload should be restricted (for example, the maximum single - upload size is 400k and the occupied time does not exceed 200ms). However, the emergency upload at this time is not restricted by this and should immediately upload all the staged logs as fast as possible. For example, it can upload 4000k at a time, and if there are more logs after that, it will continue to upload immediately. It has nothing to do with the size and number limits of storing single - log entries in the database. The consideration of the size and number limits of single - log entries is mainly to prevent a single log from being too large and to prevent too many logs from piling up and exhausting the disk space. Generally, this quota will be large enough.

[0095] It is not excluded that due to the user's emergency closure or possible network fluctuations of the user, some staged logs are not uploaded to the server in time. Since these staged logs will be permanently stored on the user's local side (without the user manually clearing them), in the application design, the above - mentioned worker upload process can be started at the entrance page or even in the global initialization logic. As long as the user accesses the application again later, the log information left over from the previous upload that was not completed will be immediately started.

[0096] Optionally, in an embodiment of this application, the method further includes:

[0097] If the application thread monitors that the target application starts to run, start the monitoring thread;

[0098] Receive log information through the monitoring thread and report the log information to the server through another thread.

[0099] In some possible embodiments, the present application will open an additional thread within the application to report log information to the log collection server without affecting the performance of the application; the additional thread is regarded as a monitoring thread, and the log information generated by the target application is monitored through this monitoring thread. Of course, the method of monitoring a process can also be adopted. When the process monitors that the application or the application starts running, the monitoring process is started, and the collection and monitoring of log information are realized through the monitoring process. In some embodiments, if it is monitored that the game starts running, the monitoring thread is started to receive log information in real time. Specifically, it can be determined whether the game starts running through the game thread. Exemplarily, the game thread can determine that the game starts running through an event-driven mechanism. It can be understood that when the game is started, a "game start" event will be triggered. The game thread can subscribe to this event. Once the event is received, it can be determined that the game starts running. Exemplarily, in the Unity game engine, developers can utilize its event function. When a game object is enabled, the function of its affiliated script will be called, and the game thread determines that the game starts running and starts the monitoring thread. In some other embodiments, the game thread can also determine whether the game starts running by checking a status flag. Exemplarily, a variable representing the game state and its initial value are set. In the code flow of game initialization and start, when all necessary initialization steps are completed, the value of this variable is reset. The game thread can periodically check this variable. When it is found that it becomes the reset value, it is determined that the game starts running. Of course, the present application does not limit the method of determining that the game starts running.

[0100] In the present application, the monitoring thread established receives log information from the client and then reports the log information to the server, realizing the real-time acquisition and reporting of log information, facilitating relevant personnel to query and process the log information, and improving the efficiency of log information processing.

[0101] Optionally, in an embodiment of the present application, reporting the log information to the server includes:

[0102] Obtain the cumulative duration; the cumulative duration is the duration elapsed since the last log information report;

[0103] If the cumulative duration is greater than or equal to the preset duration, report the log information to the server through another thread and return to the step of obtaining the cumulative duration;

[0104] Or, if the number of current log information entries is greater than or equal to the preset number, report the log information to the server through another thread.

[0105] In some possible implementation manners, after receiving the log information, the monitoring thread may set a log reporting policy to determine the timing of log reporting. In some embodiments, the timing of log reporting may be determined by time attributes. Exemplarily, the log information received within the current period may be reported to the server periodically; that is, the preset duration in the present application is used to represent the frequency of log reporting. The preset duration may be set according to the type of the game, the current time, whether it is a holiday currently, whether it is a working day currently, etc., and the present application does not limit the specific value of the preset duration. It should be noted that in some other embodiments, the preset duration may also be a variable value. Specifically, different preset durations are set for different times and different situations to dynamically adjust the collection timing of the log information, which is beneficial to improving the accuracy of the collected log information.

[0106] In some other embodiments, the timing of log reporting may be determined by the number of log entries collected within the current period. When the number of unreported log entries collected is greater than or equal to the preset number, the log reporting process is executed. It can be understood that the preset number in the present application is the acceptable number of log entries reported at one time. Of course, those skilled in the art can also set the timing of log reporting according to actual needs, and the present application does not make specific limitations.

[0107] Optionally, in an embodiment of the present application, the method further includes:

[0108] When the target application is applied to the client, initialize the log reporting interface through the software development kit;

[0109] Report the basic information of the client to the server through the log reporting interface, so that the server can integrate and process the log information according to the basic information.

[0110] In some possible implementation manners, the embodiments of the present application report the basic information of the client to the server to facilitate the subsequent integration and summary of the log information. Specifically, after the application thread starts, an initialization process is first executed, and the log reporting interface of the software development kit is established. At the same time, the basic information of the client is reported to the server. In some embodiments, the client basic information includes: device information: CPU, GPU, model name, device unique identifier (Universally Unique Identifier, UUID), IP address, system information, resolution. The server differentiates the log information according to the basic information, and can also integrate the log information according to the device type.

[0111] Optionally, in an embodiment of the present application, reporting the log information to the server includes:

[0112] If log information is obtained through the log output function, it is called back to the log reporting interface;

[0113] The log information is processed and reported through the callback function.

[0114] In some possible implementation manners, in Unity, the log output can be executed through the Debug.Log function, and at the same time, the log reporting interface can be connected through the callback function to receive the log information. It can be understood that other methods can also be used to implement the underlying log output in Unity: by using a custom logger class, a custom logger class can be created to output the log to a file or send it to a remote server. A third-party log framework can also be utilized to integrate the third-party log framework into the Unity project. Those skilled in the art can set the collection and reporting methods of the log information according to actual requirements, and the present application does not make specific limitations.

[0115] Optionally, in an embodiment of the present application, reporting the log information to the server includes:

[0116] Adding preset log information to the log information; the preset log information includes the scene information where the log is located, user information, and operating system information;

[0117] Combining the log information into a preset format and reporting it to the server through the first setting interface.

[0118] The present application adds preset log information such as the scene where the log is located, user information, and operating system to the log information, which is convenient for subsequent integration processing of the log information according to different parameters and for result display, improving the efficiency of log information processing.

[0119] In some possible implementation manners, the embodiments of the present application combine the log information into a preset format to report it to the server through the first setting interface. Correspondingly, for the basic information of the client, the basic information is combined into a preset format to report it to the server through the second setting interface. Those skilled in the art can set the required data type (i.e., preset format) and the first setting interface for reporting according to the actual valid type and the matching of the SDK and the server.

[0120] Optionally, in an embodiment of the present application, the method further includes:

[0121] If the client is a mobile terminal, collecting the log information through the log recording tool provided by the system (exemplarily, such as Logcat) or by connecting to the integrated development environment (exemplarily, it can be by connecting to XCode);

[0122] Or, if the client is a computer device, collecting the log information through a general editor (exemplarily, it can be Unity).

[0123] In some possible embodiments, the present application does not limit the specific type of the client. For different types of clients, the way of obtaining logs can be adaptively adjusted. For a mobile terminal, such as a mobile phone, the way of obtaining log information can be determined according to the installed system. For a computer device (PC side), log information can be collected through the Unity editor.

[0124] On the other hand, the present application provides a log processing method applied to a server, including the following steps:

[0125] Receiving log information collected and reported by a target application through a software development kit;

[0126] Integrating and processing the log information, and sending the integrated processing result to the front-end page so that the front-end page can display the integrated processing result.

[0127] It can be understood that the server in the present application integrates and processes the received log information and forwards it to the front-end page for display; the application program of the client in the present application accesses the development kit and reports the logs in the game regularly or quantitatively through a callback function. The present application collects log information in real time through the software development kit, which is beneficial to improving the timeliness of log collection; and integrates and displays the log information to improve the efficiency of log processing.

[0128] Optionally, in an embodiment of the present application, the method further includes:

[0129] Appending log information from the client database to a preset file address through an appendable object in the object storage service;

[0130] Determining the storage duration of the log information according to the log level, and performing deletion or permanent preservation processing on the log information according to the storage duration.

[0131] When the target application is a web application, for the upload of temporarily stored logs, it is necessary to upload them to the server storage as soon as possible to prevent the inability to execute the upload logic after the user closes the page, which will cause log loss. To facilitate log search, the application defines the file address for the current log upload by itself. Generally, a file address is generated according to the date, user identifier, and page information according to the agreed rules, and all the logs temporarily stored on the current page will be uploaded to this file address one after another.

[0132] Exemplarily, client_log / appName / 20XX / XX / XX / pageName / prod-user-1234567.log. In this example, client_log is the unified root directory, appName is the agreed application name, 20XX / XX / XX is generated according to the time and date when the log is generated, pageName is the agreed page flag, and prod-user-xxxx.log is generated according to the user flag (usually UID). In this way, it is very convenient to know the upload and storage address of all the logs generated by the specified user UID on the specified date, application, and page.

[0133] Thanks to the convenience of the current object storage service (OSS service), this solution directly uses the OSS service in the cloud market and uses the appendable object (Appenddable type Object) in OSS. The log content is continuously appended to the agreed file address mentioned above. When uploading for the first time, first obtain the current position of the file, and then start appending content from this position. Regularly take out the earliest N logs from the local log staging queue, and delete the corresponding local records after successful upload. That is, through the appendable object in the object storage service, the log information is appended from the client database to the preset file address. In some other embodiments, if the target application is an application program (APP), through the appendable object in the object storage service, the log information is appended from the software development kit to the preset file address.

[0134] This application also provides a function of automatically clearing expired logs. If these uploaded logs are collected without distinction, it may generate a relatively large amount of data for web applications with a large number of user accesses. And these logs are only used when analyzing problems, which also means that most of the log files may not be used, and the longer the time, the lower the possibility of being used. Therefore, a validity period will be set for each file, such as 1 month, and it will be automatically deleted after expiration. It needs to be used within 1 month. If you encounter relatively important log files, you need to save them by yourself. In some other embodiments, it can be considered to store the logs with relatively serious levels, such as warn, error, etc., separately as a single unit according to the log levels mentioned above, and set a longer storage period. It is also possible to classify and statistically analyze these severely leveled logs, and the analysis data can be persistently stored.

[0135] Optionally, in an embodiment of this application, the log information is integrated and processed, including:

[0136] Integrating and processing the log information according to the hash value corresponding to the log stack of the log information;

[0137] And / or, integrate and process the log information according to the scenario information;

[0138] And / or, integrate and process the log information according to the device information;

[0139] And / or, integrate and process the log information according to the alarm information.

[0140] In some possible implementation manners, the present application integrates the log information from multiple perspectives, facilitating the user to view the log information from multiple aspects. In some embodiments, the log information includes stack information, the stack information is subjected to hash processing, and the log information is integrated according to the obtained hash value. It can be understood that the hash value can represent the fingerprint of the data and serve as a unique identifier of the log stack content. Through the hash value, it can be quickly determined whether the log stacks obtained at different time points are the same set of content, so as to group the log information. In some embodiments, the integration of the log stack information can be performed through the md5 code. It should be noted that the md5 code is an encoding generated by an information digest algorithm, which converts data of any length into a hash value of a fixed length (128 bits), usually represented by a 32-bit hexadecimal number. Therefore, the integration of the log stack information can be achieved through the md5 code.

[0141] In another embodiment, the log information can be integrated through the scenario information. Specifically, the log information can be integrated according to the system operation and maintenance scenario. In some embodiments, classification and summarization are performed according to system resources, which may be to pay attention to the resource usage of the system, such as CPU, memory, disk I / O, etc., and summarize the logs related to these resources. In other embodiments, classification and summarization are performed according to the service status, which may be to summarize the logs related to the state changes such as startup, stop, and restart of various services (such as Web services, database services, etc.). Of course, the log information can also be integrated according to the security audit scenario. In some embodiments, classification and summarization are performed according to player behaviors, focusing on behaviors such as player login, logout, and permission change. In other embodiments, classification and summarization are performed according to security events, and summarize the security-related logs such as detected virus infections, intrusion attempts, and firewall interceptions. The log information can also be integrated according to the application development scenario, such as classification and summarization according to functional modules.

[0142] In some embodiments, the log information is integrated according to the alarm information, facilitating the customer to query all the log information related to the alarm information.

[0143] Optionally, in an embodiment of the present application, the method further includes:

[0144] Display the running log interface, receive a trigger operation on the first control in the running log interface, and display the daily statistics area;

[0145] The daily statistics area receives an editing operation or a selection operation on preset information and displays the integrated log information; the preset information is used to filter the log information.

[0146] In some possible implementations, the present application provides a visual interface for retrieving and displaying log information, which is convenient for customers to intuitively view log information. Exemplarily, the front-end page in the present application is used for data display, which helps developers locate problems with program games and manage program logs. It is understandable that the visual interface can be displayed through the first terminal (front-end page), which can be a terminal of relevant operation and maintenance personnel, or a staff member who manages the operation of the game. In some embodiments, refer to Figure 4 In the visual interface shown, there are multiple options for customers to choose from in the menu bar area on the left side of the operation log interface to determine the specific log information to view; each option triggers an action through the corresponding control. For example, the controls in the menu bar area may include: real-time log, query details, daily statistics, configuration settings, etc., providing customers with ways to filter logs from different angles. Among them, the daily statistics control is the first control in this application, which provides customers with daily log information. Figure 4 In the operation log interface, the right area is the daily statistics area. The upper end of the daily statistics area is the preset information, which is convenient for users to set filtering rules. That is, the preset information in this application is the integration rule for integrating log information. Figure 4 As shown, the preset information can be information such as statistical date, merging method, log type, status, etc., which can be set by technical personnel in this field according to actual needs. In actual operation, the customer determines the preset information by selecting or editing according to the setting method of each preset information. The system will integrate the log information according to the preset information set by the customer, and display the integration results through the lower area of the daily statistics area. The daily statistics area in this application can display data that the server has classified and counted according to information such as error type, version, scenario, model, etc. The log of the day can be displayed, and the displayed data can be sorted from high to bottom according to the log information; you can also choose to display only a certain type, or specify to view a certain log.

[0147] In other embodiments, for a single log, you can view the version, map name, machine model, operating system and other related information. For example, you can display the version and the number of logs for each version in the relevant area; you can also display the maps and the number of logs for each map. Figure 5 As shown; the machine model and operating system can also be displayed. Of course, this application does not limit the specific information displayed and the specific layout of the interface.

[0148] In some embodiments, the present application provides a real-time viewing function for logs, which facilitates technicians to view the logs during the game operation in real time. Specifically, the log viewing function is triggered by the real-time log control on the running log interface, and the real-time log area is displayed, such as Figure 6 the real-time log area shown in the right area in Figure 6 , and the latest log information generated currently is displayed, which is convenient for technicians to view and analyze. In this example, by inputting the IP, the real-time logs uploaded by a certain device can be viewed in real time, and the reporting conditions can also be set for filtering and viewing.

[0149] Optionally, in an embodiment of the present application, the method further includes:

[0150] Receiving a triggering operation on the second control on the running log interface, and displaying a configuration setting area;

[0151] Receiving an editing operation on the alarm information in the configuration setting area, and if the log information includes alarm information, sending the log information to the target object.

[0152] The embodiment of the present application provides an alarm mechanism for abnormal logs. Through relevant configurations, when abnormal log information that needs attention appears, the system automatically pushes the log information to the target object. In some embodiments, the configuration is triggered by the configuration setting control on the running log interface, and the configuration setting control is the second control in the present application. Through the second control, the configuration setting area is triggered to be displayed, and the log information to be concerned is configured in the configuration setting area, relevant alarm information is edited, and the alarm information is used as the judgment condition for log pushing, and the log information containing the alarm information is pushed in real time. It can be understood that the alarm information in the present application is the concerned content included in the log information that needs attention. In a specific example, add in the configuration such as: can only be called from the main thread (i.e., the alarm information in the present application). When the log information contains this alarm information (it can also be a log), it will be notified and reminded through an instant messaging tool. Relevant technicians can also jump to the detailed information interface of the log information by viewing the details to view the log information, as shown in Figure 7 shown.

[0153] In some embodiments, the present application provides log information query requests from multiple perspectives. Users can set the query conditions for the required log information according to their needs, so as to filter out the required log information from numerous data. Specifically, by triggering the query details control on the running log interface, a detailed search for the log information is triggered, and the query details area is displayed, as shown in Figure 8The query details area shown in the right part of the interface. The user can set query conditions from multiple perspectives such as device IP, operating system, machine model, log type, project version, etc. The background server receives the query conditions, integrates / filters the log information according to the query conditions, obtains the integration result based on the query conditions, and displays it through the Figure 8 query details area in. This application provides users with query diversity, improves the convenience of log analysis, and thus improves the log analysis efficiency.

[0154] In some embodiments, for any log information, the user can also view the detailed information of the client device corresponding to the log information, bind the log information with the device information, which is convenient for the user to view the device information in real time and is convenient for fault analysis. Refer to Figure 9 As shown, by triggering the log information control, the device information viewing area is displayed. Of course, this application does not limit the specific functions of the visualization interface, and those skilled in the art can set the log display method of the visualization interface according to actual needs.

[0155] The following uses specific embodiments to describe in detail the log processing method proposed in this application. For the application program:

[0156] Regarding the client reporting in this application: Build a set of log automatic reporting systems. The game simply accesses a log collection SDK. This solution supports multiple platforms: mobile, PC, and host platforms. By initializing in the game, configuring the timing reporting interval (i.e., the preset duration in this application), the reporting size (i.e., the preset number of entries in this application), etc.; Exemplarily, the default can be 5 minutes and 500 entries. A separate thread will be opened in the game to regularly report the logs to the log collection server without affecting the performance of the game.

[0157] Regarding the server processing in this application: By obtaining the user's logs in a timely manner, the server will classify and process the information in a timely manner after receiving it, and display the classified and statistical data on the web page. The system supports PC, mobile (Android, iOS), and host platforms (such as the TV game console XBox and the video game console PS5).

[0158] The interaction between the client and the server, the implementation principle includes:

[0159] Through the initialization interface provided by the SDK, initialize the self-developed KGLogger reporting interface (i.e., the log reporting interface in this application): KGLogger.Init("project name"); At the same time of initialization, the client information will be reported to the log collection server: device information: CPU, GPU, model name, device unique identification uuid, IP address, system information, resolution;

[0160] Log information: The unique uuid at initialization, client account information, and client version number information; at this time, the client starts collecting log information / data. When the number of entries reaches a predetermined number or time (e.g., the default: 500 entries, 5 minutes), the client will start another thread to report the log content to the collection server;

[0161] The log content includes: the stack of the log, error type, the scenario where the log is output, and time;

[0162] The log collection server further processes based on the received logs:

[0163] Summarize according to the log stack: A md5 code (i.e., the hash value in this application) will be calculated based on the reported log stack, and the same md5 logs will be grouped together to facilitate viewing the number of occurrences of this type of log; the number of logs of the same type will be summarized regularly every day to notify the developers to follow up in a timely manner;

[0164] Summarize according to the scenario: Summarize the logs of the same scenario together to more quickly locate the situation of a certain scenario;

[0165] Summarize according to the device: You can view all the logs of a single device separately, which is convenient for viewing the context when locating problems;

[0166] Alarm according to the content: Users can set the content of the log for monitoring. When the server collects relevant logs, an alarm will be issued, and the corresponding device and person can be found in time for processing;

[0167] Front-end platform data display: It can be viewed according to different data summaries, or further filtered and keyword searched.

[0168] Details of the implementation of the client SDK:

[0169] The SDK outputs logs through the Hoop Unity underlying Debug.unityLogger.Log function. When logs are generated in the game, such as: normal logs, warning logs, error logs, and exception logs, it will call back to the reporting interface KGLogger; in addition, a process outside the game is started. When the conditions of fixed time and fixed quantity are reached, the logs will be reported to the server. It can be understood that Hoop can be a custom script or plugin for setting the form of log output, etc.

[0170] Implementation principle and operation principle of log reporting (APP side):

[0171] Obtain the above information (i.e., the basic information in this application) through the API provided by Unity: CPU, GPU, model name, device unique identification uuid, IP address, system information, resolution;

[0172] Combine the data into a JSON string (i.e., the preset format in this application), and then call the interface agreed with the server (i.e., the second preset interface in this application): http: / / 10.*.*.* / upload / client / info to upload the content to the server;

[0173] When the game runs and outputs logs, such as: UnityEngine.Debug.LogError("Hello World!"); it will call back to the Hoop function (i.e., the callback function in this application) OnLogHandle(string condiction,string stackTrace,LogType logType), and the log content, stack trace, and log type will be passed in;

[0174] The callback function processes according to the content of the log, such as: client time, log trigger scenario, game version number, operating system, machine model information, used character, game state (battle, walking, plot), etc.; according to the above conditions, classify and summarize the logs, and then display the processed log content on the front-end page;

[0175] After combining into JSON format, use the interface agreed with the server (i.e., the first preset interface in this application): http: / / 10.*.*.* / upload / client / logs to upload to the server.

[0176] Principle and operation principle of log reception (server side) data summary:

[0177] Log reception: The server will process the received different logs and store them in the database respectively;

[0178] Log summary processing: The server will correlate according to the logs. Through the device ID, all the reported log information of a single device can be correlated; through the log stack, the number of logs can be counted; these are all processed by the background through SQL statements;

[0179] Warning: The server will check the content of the received logs. If a preset log appears, it will notify the corresponding person via email or other instant communication tools through SendWarning(string stackTrace,LogType logType).

[0180] In summary, this application enables real-time viewing of log details on the front-end page. By inputting the client IP address, device name, and unique device number of the device, the real-time logs of users can be viewed on the front-end page of the log display. For users who have not connected to KGLogger, they can only obtain logs through Logcat provided by the Android system. For Apple mobile phones, they need to connect to XCode, and for the PC side, they need to connect to the Unity editor, etc. This application is more convenient for problem location. Through the detailed log information, it is possible to know the scenarios where exceptions occur, the roles used, whether they occur under a certain GPU or CPU, or on a certain machine. This application can achieve summarization. Logs can be summarized according to the set time to view the situations of game exceptions, errors, and warnings. During the process of reporting logs, this application can add monitoring and issue timely warnings for exceptions.

[0181] This application collects all logs reported by game clients in real time and provides a workflow solution for the log processing server. This solution well solves the problems in the related technologies and achieves: reporting once every preset duration, enabling timely reporting; the size of each upload is controllable (adjustable according to the game itself) and will not cause game lag; the background can classify, summarize, and give warnings for the reported logs, etc.

[0182] The following uses another specific embodiment to describe in detail the log processing method proposed by this application. If the target application is a web application:

[0183] Step S21: Introduce the SDK.

[0184] The project introduces the SDK implemented by this application and sets some configurations of the project, such as the current project flag, user flag, log file path, upload frequency, interval, etc. Among them, the key log file path rules are agreed upon, such as generating a path according to the project, date, user flag, etc., to facilitate subsequent retrieval.

[0185] Step S22: Log recording.

[0186] For key page accesses, user operations, interface requests and responses, etc. and corresponding parameter information in the project code, they are marked and recorded according to the log level (e.g., debug, info, warning, error). The SDK will automatically mark key information such as the page to which the current log belongs, the occurrence time, and the serial number.

[0187] Step S23: Log upload.

[0188] This step is automatically completed by the SDK. According to the SDK configuration in the first step and the log information recorded by the project in the second step, it will automatically collect, temporarily store, and upload to the specified path.

[0189] Step S24: Log analysis.

[0190] When receiving user feedback, according to the log path rules agreed upon in the project, it is easy to obtain the user's log storage path at that time, find the log file at that time, and analyze the problem based on the detailed log information recorded.

[0191] This application can automatically and real-time obtain the full amount of log information of the target application, greatly facilitating the troubleshooting of some occasional, difficult-to-reproduce, and abnormal problems related to the user's device environment in web applications, and reducing the solution cycle of user feedback. This application can achieve full-volume persistent collection: first, use the underlying method of intercepting logs on the device to obtain the full amount of log information, and then store it on the device disk with the help of a local database, and persistently save it before successful upload or manual deletion by the user. Even if the user closes the page, the data can be guaranteed not to be lost. This application can achieve real-time upload: without affecting the user experience, it can upload the log content to the specified server address in real-time, without the need to communicate with the user about the incident scenario manually, greatly facilitating developers to troubleshoot faults.

[0192] In summary, the embodiment of this application proposes a log processing method, including the following steps: integrating a software development kit into the target application; collecting the log information of the target application through the software development kit and reporting the log information to the server, so that the server integrates and processes the log information and enables the server to display the integrated processing result through the front-end page. The embodiment of this application collects log information in real-time through the software development kit, which is beneficial to improving the timeliness of log collection; and integrates and displays the log information to improve the efficiency of log processing.

[0193] Secondly, refer to the attached Figure 10 Describe a log processing system proposed according to the embodiment of this application. The system specifically includes:

[0194] The first module 301 is used for:

[0195] Integrating a software development kit into the target application;

[0196] Collecting the log information of the target application through the software development kit and reporting the log information to the server, so that the server integrates and processes the log information and enables the server to display the integrated processing result through the front-end page;

[0197] And / or, the second module 302 is used for:

[0198] Receiving the log information collected and reported by the target application through the software development kit;

[0199] Integrate and process the log information, and send the integration and processing results to the front-end page so that the front-end page can display the integration and processing results.

[0200] It can be seen that the content in the above method embodiments is applicable to the system embodiments of the present application. The functions specifically implemented in the system embodiments of the present application are the same as those in the above method embodiments, and the beneficial effects achieved are also the same as those achieved in the above method embodiments.

[0201] Refer to Figure 11 , the embodiment of the present application provides a log processing device, including:

[0202] At least one processor 410;

[0203] At least one memory 420 for storing at least one program;

[0204] When at least one program is executed by at least one processor 410, the at least one processor 410 implements the log processing method described above.

[0205] Similarly, the content in the above method embodiments is applicable to the device embodiments of the present application. The functions specifically implemented in the device embodiments of the present application are the same as those in the above method embodiments, and the beneficial effects achieved are also the same as those achieved in the above method embodiments.

[0206] The embodiment of the present application also provides a computer-readable storage medium, in which a program executable by a processor is stored, and the program executable by the processor is used to execute the log processing method described above when executed by the processor.

[0207] Similarly, the content in the above method embodiments is applicable to the storage medium embodiments of the present application. The functions specifically implemented in the storage medium embodiments of the present application are the same as those in the above method embodiments, and the beneficial effects achieved are also the same as those achieved in the above method embodiments.

[0208] In some alternative embodiments, the functions / operations mentioned in the block diagram may not occur in the order mentioned in the operation diagram. For example, depending on the functions / operations involved, two consecutive blocks shown may actually be executed substantially simultaneously or the blocks can sometimes be executed in the reverse order. In addition, the embodiments presented and described in the flowcharts of the present application are provided by way of example for a more comprehensive understanding of the technology. The disclosed method is not limited to the operations and logical flows presented herein. Alternative embodiments are foreseeable, in which the order of various operations is changed and the sub-operations described as part of a larger operation are executed independently.

[0209] In addition, although the present application has been described in the context of functional modules, it should be understood that, unless otherwise stated to the contrary, one or more of the functions and / or features may be integrated in a single physical device and / or software module, or one or more functions and / or features may be implemented in separate physical devices or software modules. It should also be understood that a detailed discussion of the actual implementation of each module is not necessary for understanding the present application. Rather, given the attributes, functions, and internal relationships of the various functional modules in the devices disclosed herein, the actual implementation of the modules will be understood within the ordinary skills of an engineer. Thus, those skilled in the art can implement the present application as set forth in the claims without undue experimentation. It should also be understood that the specific concepts disclosed are merely illustrative and are not intended to limit the scope of the present application, which is determined by the full scope of the appended claims and their equivalents.

[0210] If the described function is implemented in the form of a software functional unit and sold or used as an independent product, it can be stored in a computer-readable storage medium. Based on this understanding, the technical solution of the present application, in essence, or the part that contributes to the prior art, or a part of this technical solution, can be embodied in the form of a software product. This computer software product is stored in a storage medium and includes several programs for causing a computer device (which may be a personal computer, a server, or a network device, etc.) to execute all or part of the steps of the methods described in the various embodiments of the present application. The aforementioned storage medium includes: various media such as USB flash drives, external hard drives, read-only memory (ROM), random access memory (RAM), magnetic disks, or optical discs that can store program codes.

[0211] The logic and / or steps represented in the flowchart or otherwise described herein, for example, can be considered as a sequenced list of executable programs for implementing logical functions, and can be specifically implemented in any computer-readable medium for use by a program execution system, apparatus, or device (such as a computer-based system, a system including a processor, or other systems that can retrieve and execute programs from the program execution system, apparatus, or device), or in conjunction with these program execution systems, apparatuses, or devices. For the purposes of this specification, a "computer-readable medium" can be any device that can contain, store, communicate, propagate, or transport a program for use by or in conjunction with a program execution system, apparatus, or device.

[0212] More specific examples (nonexhaustive list) of computer-readable media include the following: an electrical connection (electronic device) having one or more wirings, a portable computer diskette (magnetic device), a random access memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or flash memory), an optical fiber device, and a portable compact disc read-only memory (CDROM). Additionally, the computer-readable media can even be paper or other suitable media on which the program can be printed, since the program can be obtained electronically, for example, by optically scanning the paper or other media, followed by editing, interpretation, or otherwise processing as appropriate, and then storing it in a computer memory.

[0213] It should be understood that the various parts of the present application can be implemented by hardware, software, firmware, or a combination thereof. In the above-described embodiments, multiple steps or methods can be implemented by software or firmware stored in a memory and executed by a suitable program execution system. For example, if implemented by hardware, as in another embodiment, any one or a combination of the following techniques known in the art can be used: discrete logic circuits having logic gate circuits for implementing logical functions on data signals, application-specific integrated circuits having appropriate combinational logic gate circuits, programmable gate arrays (PGAs), field-programmable gate arrays (FPGAs), and the like.

[0214] In the foregoing description of the present specification, the descriptions referring to the terms "one embodiment / example", "another embodiment / example", or "certain embodiments / examples", etc. mean that the specific features, structures, materials, or characteristics described in connection with the embodiment or example are included in at least one embodiment or example of the present application. In this specification, the schematic representations of the above terms do not necessarily refer to the same embodiment or example. Moreover, the specific features, structures, materials, or characteristics described can be combined in any one or more embodiments or examples in a suitable manner.

[0215] Although the embodiments of the present application have been shown and described, those of ordinary skill in the art can understand that various changes, modifications, substitutions, and variations can be made to these embodiments without departing from the principles and spirit of the present application, and the scope of the present application is defined by the claims and their equivalents.

[0216] The above has specifically described the preferred embodiments of the present application, but the present application is not limited to the described embodiments. Those skilled in the art can also make various equivalent deformations or substitutions without departing from the spirit of the present application, and these equivalent deformations or substitutions are all included within the scope defined by the claims of the present application.

Claims

1. A log processing method, characterized in that, The method includes the following steps: Integrate a software development kit (SDK) into the target application; Collect log information of the target application through the SDK, and report the log information to a server, so that the server integrates and processes the log information, and the server displays the integrated processing result through a front-end page.

2. The log processing method according to claim 1, wherein The target application is a web application. The step of collecting log information of the target application through the SDK and reporting the log information to the server includes: Collect the log information through the SDK and format the log information; Temporarily store the log information in a database through a worker process, and report the log information to the server based on configuration information; the configuration information is the setting of the storage space and reporting parameters of the log.

3. The log processing method according to claim 1, wherein The method further includes: If an application thread monitors that the target application starts running, start a monitoring thread; Receive the log information through the monitoring thread and report the log information to the server through another thread.

4. The log processing method according to claim 1, wherein The step of reporting the log information to the server includes: Obtain the cumulative duration; the cumulative duration is the duration elapsed since the last log information report; If the cumulative duration is greater than or equal to a preset duration, report the log information to the server through another thread, and return to the step of obtaining the cumulative duration; Alternatively, if the number of current log information entries is greater than or equal to a preset number, report the log information to the server through another thread.

5. The log processing method according to claim 1, wherein The method further includes: When the target application is applied to a client, initialize a log reporting interface through the SDK; Report the basic information of the client to the server through the log reporting interface, so that the server integrates and processes the log information according to the basic information.

6. The log processing method according to claim 1, wherein The step of reporting the log information to the server includes: If log information is obtained through a log output function, call back to the log reporting interface; Process and report the log information through a callback function.

7. The log processing method according to claim 1, characterized in that The step of reporting the log information to the server includes: Add preset log information to the log information; the preset log information includes log scenario information, user information, and operating system information; Combine the log information into a preset format and report it to the server through a first setting interface.

8. A log processing method, characterized in that, When applied to a server, the method includes the following steps: Receive log information collected and reported by the target application through the SDK; Integrate and process the log information, and send the integrated processing result to a front-end page, so that the front-end page displays the integrated processing result.

9. The log processing method according to claim 8, wherein The method further includes: Append the log information to a preset file address through an appendable object in an object storage service; Determine the storage duration of the log information according to the log level, and clear or permanently save the log information according to the storage duration.

10. The log processing method according to claim 8, wherein The step of integrating and processing the log information includes: Integrate and process the log information according to the hash value corresponding to the log stack of the log information; and / or, integrate and process the log information according to the scenario information; and / or, integrate and process the log information according to the device information; and / or, integrate and process the log information according to the alarm information.

11. The log processing method according to claim 8, wherein The method further includes: Display a running log interface, receive a trigger operation on a first control in the running log interface, and display a daily statistics area; Receive an editing operation or a selection operation on preset information in the daily statistics area, and display the integrated log information; the preset information is an integration rule for integrating the log information.

12. The method according to claim 11, wherein The method further includes: Receive a trigger operation on a second control in the running log interface, and display a configuration setting area; Receive an editing operation on alarm information in the configuration setting area, and if the log information includes the alarm information, send the log information to a target object.

13. A log processing system, characterized in that, The system includes: A first module for: Integrate a software development kit into a target application; Collect log information of the target application through the software development kit, and report the log information to a server, so that the server integrates and processes the log information, and enables the server to display the integrated processing result through a front-end page; and / or, a second module for: Receive log information collected and reported by a target application through a software development kit; Integrate and process the log information, and send the integrated processing result to a front-end page, so that the front-end page displays the integrated processing result.

14. A log processing device, characterized in that, Includes: At least one processor; At least one memory for storing at least one program; When the at least one program is executed by the at least one processor, the at least one processor implements the log processing method according to any one of claims 1 to 12.

15. A computer-readable storage medium storing a program executable by a processor, characterized in that, The program executable by the processor is used to implement the log processing method according to any one of claims 1 to 12 when executed by the processor.

Images