A method and device for processing crash information

Abstract

The present application discloses a method and apparatus for processing crash information, which relates to the field of computer technology. A specific implementation manner includes receiving program crash information, obtaining the crash file name in the program crash information, and then determining the crash version branch information. The corresponding information summary set is obtained from the system configuration file through the crash version branch information; the crash file name is matched with all the information summaries in the information summary set to determine the crash processing node corresponding to the crash file name; and the program crash information is sent to the crash processing node. Thus, this implementation manner can achieve timely notification of program crash information to relevant responsible persons, quickly respond to and process program crash problems, and avoid the expansion of problems.

Description

Technical Field

[0001] This application relates to the field of computer technology, and in particular, to a method and apparatus for processing crash information. Background Art

[0002] With the development of enterprises, their own business is increasing, resulting in a growing number of software modules, which easily causes system crashes. Most enterprises have their own crash collection systems and can view crash logs. Due to the large scale of the software and the large number of business lines involved, the collected crash logs are also very messy.

[0003] In the process of implementing this application, the inventors found that there are at least the following problems in the prior art:

[0004] It is difficult to collect crash information of relevant crash modules from a large amount of data, and it is impossible to quickly respond to solve problems. Summary of the Invention

[0005] In view of this, embodiments of this application provide a method and apparatus for processing crash information, which can solve the technical problem that it is difficult to collect crash information of relevant crash modules from a large amount of data and it is impossible to quickly respond to solve problems in the prior art.

[0006] To achieve the above object, according to one aspect of the embodiments of this application, a method for processing crash information is provided, including:

[0007] Receiving program crash information, obtaining the crash file name in the program crash information, and then determining the crash version branch information, and obtaining the corresponding information summary set from the system configuration file through the crash version branch information;

[0008] Matching the crash file name with all the information summaries in the information summary set to determine the crash processing node corresponding to the crash file name;

[0009] Sending the program crash information to the crash processing node.

[0010] Optionally, determining the crash version branch information includes:

[0011] In response to determining that there is a matching crash module for the crash file name, determining the matching crash module as the program crash module corresponding to the program crash information;

[0012] Obtaining the crash version branch information corresponding to the program crash module.

[0013] Optionally, obtaining the corresponding information summary set includes:

[0014] Invoking a preset script code to obtain the version branch commit record corresponding to the crash version branch information from the system configuration file;

[0015] Obtain the set of information digests corresponding to the crash version branch information from the version branch commit records.

[0016] Optionally, before matching the crash file name with all the information digests in the set of information digests, the crash information processing method further includes:

[0017] In response to determining that no crash version branch information is determined, call a preset script code to obtain the version branch commit records corresponding to the version branch information of all modules from the system configuration file;

[0018] Obtain the set of information digests corresponding to all the version branch information from the version branch commit records.

[0019] Optionally, determining the crash handling node corresponding to the crash file name includes:

[0020] Obtain the set of modified file information corresponding to the set of information digests, and then determine the set of modified file names corresponding to the set of modified file information;

[0021] Reverse the order of the version branch commit records, and then match all the modified file names in the set of modified file names with the crash file name according to the reversed version branch commit records to determine the modified file name corresponding to the crash file name;

[0022] Determine the crash handling node corresponding to the crash file name according to the modified file name corresponding to the crash file name and the corresponding relationship between the preset modified file name and the crash handling node in the set of information digests.

[0023] In addition, the present application further provides a crash information processing device, including:

[0024] A receiving unit, configured to receive program crash information, obtain the crash file name in the program crash information, and then determine the crash version branch information, and obtain the corresponding set of information digests from the system configuration file through the crash version branch information;

[0025] A crash handling node determination unit, configured to match the crash file name with all the information digests in the set of information digests to determine the crash handling node corresponding to the crash file name;

[0026] A sending unit, configured to send the program crash information to the crash handling node.

[0027] Optionally, the receiving unit is further configured to:

[0028] In response to determining that there is a matching crash module for the crash file name, determine the matching crash module as the program crash module corresponding to the program crash information;

[0029] Obtain the crash version branch information corresponding to the crashed module.

[0030] Optionally, the receiving unit is further configured to:

[0031] Call a preset script code to obtain the version branch commit records corresponding to the crash version branch information from the system configuration file;

[0032] Obtain the information summary set corresponding to the crash version branch information from the version branch commit records.

[0033] Optionally, the receiving unit is further configured to:

[0034] In response to determining that no crash version branch information is determined, call a preset script code to obtain the version branch commit records corresponding to the version branch information of all modules from the system configuration file;

[0035] Obtain the information summary set corresponding to all version branch information from the version branch commit records.

[0036] Optionally, the crash handling node determination unit is further configured to:

[0037] Obtain the modified file information set corresponding to the information summary set, and then determine the modified file name set corresponding to the modified file information set;

[0038] Reverse-order the version branch commit records, and then match all the modified file names in the modified file name set with the crashed file name according to the reverse-ordered version branch commit records to determine the modified file name corresponding to the crashed file name;

[0039] Determine the crash handling node corresponding to the crashed file name according to the modified file name corresponding to the crashed file name and the corresponding relationship between the preset modified file name and the crash handling node in the information summary set.

[0040] In addition, the present application further provides a crash information processing electronic device, including: one or more processors; a storage device for storing one or more programs, and when the one or more programs are executed by the one or more processors, the one or more processors implement the crash information processing method as described above.

[0041] In addition, the present application further provides a computer-readable medium, on which a computer program is stored, and when the program is executed by a processor, the crash information processing method as described above is implemented.

[0042] One embodiment of the above invention has the following advantages or beneficial effects: According to the crash file name in the recognizable program crash information parsed from the symbol table file received, the present application can quickly locate the crash version branch information. And based on the crash version branch information, obtain the corresponding information summary set, and match the crash file name with all the information summaries in the information summary set to quickly locate the crash processing node corresponding to the crash file name. This crash processing node can be understood as the person responsible for submitting the crash version branch information. Thus, by sending the program crash information to the crash processing node, the program crash information can be timely notified to the relevant responsible persons, quickly respond to and handle the program crash problem, and avoid the expansion of the problem.

[0043] The further effects of the above non-conventional optional manner will be described in conjunction with the specific embodiments below. BRIEF DESCRIPTION OF THE DRAWINGS

[0044] The drawings are used to better understand the present application and do not constitute an improper limitation to the present application. Among them:

[0045] Figure 1 is a schematic diagram of the main process of the crash information processing method according to the first embodiment of the present application;

[0046] Figure 2 is a schematic diagram of the main process of the crash information processing method according to the second embodiment of the present application;

[0047] Figure 3 is a schematic diagram of the application scenario of the crash information processing method according to the third embodiment of the present application;

[0048] Figure 4 is a schematic diagram of the main modules of the crash information processing device according to the embodiment of the present application;

[0049] Figure 5 is an exemplary system architecture diagram to which the embodiments of the present application can be applied;

[0050] Figure 6 is a schematic diagram of the structure of a computer system of a terminal device or a server suitable for implementing the embodiments of the present application. DETAILED DESCRIPTION OF THE EMBODIMENTS

[0051] The following describes exemplary embodiments of the present application with reference to the accompanying drawings. Various details of the embodiments of the present application are included to help understanding, and they should be considered merely exemplary. Therefore, those of ordinary skill in the art should recognize that various changes and modifications can be made to the embodiments described herein without departing from the scope and spirit of the present application. Similarly, for the sake of clarity and conciseness, the description below omits the description of well-known functions and structures.

[0052] Figure 1 is a schematic diagram of the main process of the crash information processing method according to the first embodiment of the present application. As Figure 1 shown, the crash information processing method includes:

[0053] Step S101, receive the program crash information, obtain the crash file name in the program crash information, and then determine the crash version branch information, and obtain the corresponding information summary set from the system configuration file through the crash version branch information.

[0054] In this embodiment, the execution subject of the crash information processing method (for example, it can be a server or a background processor) can receive the program crash information obtained locally or the program crash information sent from the terminal device through a wired connection or a wireless connection. Specifically, after receiving the program crash information, the execution subject can parse the program crash information to parse out the crashed file name, method name, and specific crashed code line included in the program crash information. Specifically, the parsing process can be that the execution subject receives the program crash information in the form of machine code, then obtains the dSYM symbol table file, and calls the error stack information in the program crash information in the form of machine code to compare it with the obtained symbol table file one by one to determine the recognizable crashed file name, method name, and specific crashed code line number corresponding to the program crash information in the form of machine code. The dSYM symbol table file stores the file name, method name, and code line number.

[0055] After the execution entity parses out the recognizable crash file name, method name, and specific crash code line number in the program crash information, it can obtain the crash file name from it, and match the prefix of the crash file name with the prefix of the crash module in the system to determine the crash version branch information. A relatively large application software contains multiple modules, and each module generally names files with its own prefix. For example, the file name corresponding to module A can be file A, and the file name corresponding to module B can be file B. Multiple modules make up the application software. When each module is integrated into the application software, it is necessary to enter the current version branch information of this module (including version branch name, version owner, etc.) into the crash collection system corresponding to the execution entity. When the crash collection system corresponding to the execution entity collects recognizable crash file information, the execution entity can first match the prefix of the crash file name, such as A, with the prefix of the crash module stored in the crash collection system, such as A. If the match is successful, that is, there is a matching crash module for the prefix of the crash file name, the execution entity can obtain the version branch information under the matching crash module from the crash collection system, that is, the crash version branch information. And based on the obtained crash version branch information, obtain all version commit records corresponding to the matching crash module. Each version commit record contains the information digest corresponding to the crash version branch information. All version commit records contain the information digest set corresponding to the crash version branch information. The execution entity can obtain the information digest set corresponding to all version commit records corresponding to the matching crash module from the system configuration file. The information digest, that is, SHA, can be the message digest generated by each version commit record through the hash algorithm. The information digest set can include file modification information, code submitter (i.e., file modifier) information, and file names corresponding to each piece of code.

[0056] Step S102: Match the crash file name with all information digests in the information digest set to determine the crash handling node corresponding to the crash file name.

[0057] After obtaining the information digest set, the execution entity can match the obtained crash file name with all information digests in the obtained information digest set one by one. Specifically, it can match the prefix of the crash file name with the prefix of the file names corresponding to each piece of code in each information digest in the information digest set to determine the crash handling node corresponding to the crash file name. The crash handling node can be the person in charge (also called the responsible person) who submitted the code corresponding to the crash file name or the terminal corresponding to the person in charge.

[0058] Step S103: Send the program crash information to the crash handling node.

[0059] After determining the crash handling node, the execution entity can send the program crash information, as well as the corresponding recognizable file name of the crash, method name, and specific line of code where the crash occurred, to the crash handling node for processing.

[0060] In this embodiment, based on the crash file name in the recognizable program crash information parsed from the symbol table file received, the crash version branch information can be quickly located. And based on the crash version branch information, the corresponding information summary set is obtained, and the crash file name is matched one by one with all the information summaries in the information summary set to quickly locate the crash handling node corresponding to the crash file name. This crash handling node can be understood as the person responsible for submitting the crash version branch information. Thus, by sending the program crash information to the crash handling node, the program crash information can be timely notified to the relevant responsible persons, quickly respond to and handle the program crash problem, and avoid the expansion of the problem.

[0061] Figure 2 It is a schematic diagram of the main process of the crash information processing method according to the second embodiment of the present application, as Figure 2 shown, the crash information processing method includes:

[0062] Step S201, receive the program crash information, obtain the crash file name in the program crash information, and then determine the crash version branch information, and obtain the corresponding information summary set from the system configuration file through the crash version branch information.

[0063] The principle of step S201 is similar to that of step S101, and will not be elaborated here.

[0064] Specifically, step S201 can also be implemented through steps S2011 to S2014:

[0065] Step S2011, in response to determining that there is a matching crash module for the crash file name, determine the matching crash module as the program crash module corresponding to the program crash information.

[0066] Step S2012, obtain the crash version branch information corresponding to the program crash module.

[0067] After receiving the program crash information, the execution entity first needs to determine whether there is a matching crash module for the prefix of the recognizable crash file name corresponding to the program crash information. If so, determine the determined matching crash module as the program crash module corresponding to the program crash information. And further obtain the version branch information corresponding to the program crash module, which is defined as the crash version branch information. The crash version branch information includes all the version branch information under the crash module, specifically including: version branch name, person responsible for the version branch, and other information.

[0068] In this embodiment, it is first determined whether there is a corresponding crashed module for the program crash information, which can greatly reduce the workload of information matching. It is not necessary to match the version branch information of all modules corresponding to the application one by one, which can greatly improve the processing speed of the received program crash information and help quickly match the responsible person to quickly respond to the program crash problem.

[0069] Step S2013: Invoke a preset script code to obtain the version branch commit record corresponding to the crashed version branch information from the system configuration file.

[0070] The execution entity can add some attributes to the system configuration file, such as the commit time gitCommitDate, the commit branch gitCommitBranch, and the commit summary gitCommitSHA. Thus, invoking the preset script code can obtain the version branch commit record corresponding to the crashed version branch information from the system configuration file. It can be understood that the version branch commit record can include the version branch commit time, the committed version branch, and the commit summary of this version branch.

[0071] The preset script code can be:

[0072]

[0073]

[0074] Step S2014: Obtain the set of information summaries corresponding to the crashed version branch information from the version branch commit record.

[0075] After the execution entity obtains all the version branch commit records corresponding to the crashed version branch information from the system configuration file, it can obtain the set of information summaries corresponding to each version branch commit record, that is, obtain the set of all information summaries corresponding to the crashed version branch information.

[0076] In this embodiment, by pre-setting the attributes of the system configuration file, the corresponding preset script code can be invoked to quickly obtain the set of information summaries corresponding to the version branch commit record of the crashed version branch information from the system configuration file. This helps to more quickly locate the responsible person for the program crash information to quickly respond to the program crash problem.

[0077] In some optional implementation manners of this embodiment, the program crash information processing method can also be implemented through steps S2015 to S2016:

[0078] Step S2015: In response to determining that the crashed version branch information has not been determined, invoke a preset script code to obtain the version branch commit records corresponding to the version branch information of all modules from the system configuration file.

[0079] After receiving the program crash information, the execution entity first matches the crash modules stored in the crash collection system corresponding to the execution entity according to the crash file name parsed from the program crash information, aiming to try to determine whether there is a corresponding crash module to narrow down the search scope of the responsible person (i.e., the crash handling node) information. In response to determining that no crash version branch information is determined, that is, there is no corresponding crash module for the crash file name in the crash collection system, the execution entity can call the preset script code to obtain the version branch commit records corresponding to the version branch information of all modules of the crashed application program in a traversing manner from the system configuration file. The preset script code is the same as the script code disclosed in step S2013 and will not be elaborated here.

[0080] Step S2016: Obtain the information digest set corresponding to all version branch information from the version branch commit records.

[0081] After the execution entity obtains the version branch commit records corresponding to the version branch information of all modules from the system configuration file, it can obtain the information digest set corresponding to all version branch information from the version branch records.

[0082] The crash information processing method of this embodiment is performed after the failure to determine the crash version branch information. As a supplementary solution, this embodiment can ensure that the crash handling node can be finally located by obtaining the information digest set corresponding to all modules of the crashed program, avoiding stopping the location of the crash handling node after the crash version branch information is not determined, thereby avoiding delaying the solution time of the program crash problem.

[0083] Step S202: Match the crash file name with all the information digests in the information digest set to determine the crash handling node corresponding to the crash file name.

[0084] The principle of step S202 is similar to that of step S102 and will not be elaborated here.

[0085] Specifically, step S202 can also be implemented through steps S2021 to S2023:

[0086] Step S2021: Obtain the modified file information set corresponding to the information digest set, and then determine the modified file name set corresponding to the modified file information set.

[0087] When the executing entity matches the crash file name with all the information digests in the information digest set, it can obtain the modified file information set corresponding to the information digest set. Each information digest in the information digest set may include one piece of modified file information, or may include a modified file information set composed of multiple pieces of modified file information. The modified file information set may correspond to the same line number of the code, or may correspond to different line numbers of the code. Each piece of modified file information may include the modifier of the file, the modification time of the file, the name of the modified file, the name of the modification method, etc. After the executing entity obtains each modified file information set corresponding to the information digest set, it can obtain the set of modified file names in each modified file information set.

[0088] Step S2022, reverse the order of the version branch commit records, and then match all the modified file names in the modified file name set with the crash file name according to the reversed version branch commit records to determine the modified file name corresponding to the crash file name.

[0089] In order to find the crash handling node corresponding to the program crash information at the fastest speed, the executing entity can reverse the order of the obtained version branch commit records, place the file with the latest modification submission at the front, so as to facilitate searching from the file with the latest modification submission according to the new order, quickly locate the modified file name corresponding to the crash file name, and then locate the corresponding crash handling node (that is, the modifier of the modified file name corresponding to the crash file name, also known as the responsible person, that is, the first corresponding modifier found according to the new order). Among them, matching all the modified file names in the modified file name set with the crash file name may refer to matching the full names of all the modified file names in the modified file name set with the full name of the crash file name.

[0090] Step S2023, determine the crash handling node corresponding to the crash file name according to the modified file name corresponding to the crash file name and the corresponding relationship between the preset modified file name and the crash handling node in the information digest set.

[0091] After the executing entity determines the modified file name corresponding to the crash file name, when locating the corresponding crash handling node, it can determine the crash handling node corresponding to the crash file name according to the corresponding relationship between the preset modified file name and the crash handling node in the information digest set.

[0092] In this embodiment, the full name of the crash file name is matched with the full names of all the modified file names in the modified file name set to accurately obtain the modified file name corresponding to the crash file name, and based on the corresponding relationship between the modified file name in the information digest set and the crash handling node (i.e., the responsible person), the crash handling node can be accurately located.

[0093] In some alternative implementation manners of this embodiment, each message digest further includes the method name (i.e., function name) corresponding to the modified file name. The parsed program crash information further includes the method name (i.e., function name) corresponding to the crash file name. The execution entity can also match the crash file name and method name (i.e., function name) in the program crash information with the modified file name and method name (i.e., function name) in each message digest in the message digest set one by one, so as to more accurately and quickly determine the crash handling node corresponding to the program crash information.

[0094] Step S203: Send the program crash information to the crash handling node.

[0095] The principle of step S203 is similar to that of step S103, and will not be elaborated here.

[0096] Figure 3 It is a schematic diagram of an application scenario of the crash information processing method according to the third embodiment of this application. The crash information processing method can be applied to an application scenario where the program suddenly crashes when the user runs the application version released by the client. As Figure 3 shown, the background server 303 receives the program crash information 301, obtains the crash file name 302 in the program crash information 301, and then determines the crash version branch information 304. The corresponding message digest set 306 is obtained from the system configuration file 305 through the crash version branch information 304. The background server 303 matches the crash file name 302 with all the message digests in the message digest set 306 to determine the crash handling node 307 corresponding to the crash file name 302. The background server 303 sends the program crash information 301 to the crash handling node 307.

[0097] Figure 4 It is a schematic diagram of the main modules of the crash information processing device according to the embodiment of this application. As Figure 4 shown, the crash information processing device includes a receiving unit 401, a crash handling node determination unit 402, and a sending unit 403.

[0098] The receiving unit 401 is configured to receive the program crash information, obtain the crash file name in the program crash information, and then determine the crash version branch information, and obtain the corresponding message digest set from the system configuration file through the crash version branch information.

[0099] The crash handling node determination unit 402 is configured to match the crash file name with all the message digests in the message digest set to determine the crash handling node corresponding to the crash file name.

[0100] A sending unit 403, configured as a sending unit, is configured to send program crash information to a crash handling node.

[0101] In some embodiments, the receiving unit 401 is further configured to: in response to determining that there is a matching crash module for the crash file name, determine the matching crash module as the program crash module corresponding to the program crash information; obtain the crash version branch information corresponding to the program crash module.

[0102] In some embodiments, the receiving unit 401 is further configured to: call a preset script code to obtain the version branch commit records corresponding to the crash version branch information from the system configuration file; obtain the information digest set corresponding to the crash version branch information from the version branch commit records.

[0103] In some embodiments, the receiving unit 401 is further configured to: in response to determining that no crash version branch information is determined, call a preset script code to obtain the version branch commit records corresponding to the version branch information of all modules from the system configuration file; obtain the information digest set corresponding to all version branch information from the version branch commit records.

[0104] In some embodiments, the crash handling node determination unit 402 is further configured to: obtain the modified file information set corresponding to the information digest set, and then determine the modified file name set corresponding to the modified file information set; sort the version branch commit records in reverse order, and then match all the modified file names in the modified file name set with the crash file name according to the reverse-ordered version branch commit records to determine the modified file name corresponding to the crash file name; determine the crash handling node corresponding to the crash file name according to the modified file name corresponding to the crash file name and the corresponding relationship between the preset modified file name and the crash handling node in the information digest set.

[0105] It should be noted that there is a corresponding relationship between the crash information processing method and the crash information processing device in this application in terms of specific implementation content, so the repeated content will not be described again.

[0106] Figure 5 An exemplary system architecture 500 is shown to which the crash information processing method or the crash information processing device of the embodiments of the present application can be applied.

[0107] As Figure 5 shown, the system architecture 500 may include terminal devices 501, 502, 503, a network 504, and a server 505. The network 504 is used to provide a medium for communication links between the terminal devices 501, 502, 503 and the server 505. The network 504 may include various connection types, such as wired, wireless communication links, or fiber optic cables, etc.

[0108] Users can use terminal devices 501, 502, 503 to interact with server 505 via network 504 to receive or send messages, etc. Various communication client applications can be installed on terminal devices 501, 502, 503, such as shopping applications, web browser applications, search applications, instant messaging tools, email clients, social platform software, etc. (for example only).

[0109] Terminal devices 501, 502, 503 can be various electronic devices installed with newly released or historically released application versions, including but not limited to smart phones, tablet computers, laptop portable computers, desktop computers, and so on.

[0110] Server 505 can be a server that provides various services, such as a background management server that provides support for program crash information submitted by users using terminal devices 501, 502, 503 (for example only). The background management server can receive program crash information, obtain the crash file name in the program crash information, and then determine the crash version branch information, and obtain the corresponding information summary set from the system configuration file through the crash version branch information; match the crash file name with all the information summaries in the information summary set to determine the crash processing node corresponding to the crash file name; send the program crash information to the crash processing node.

[0111] It should be noted that the crash information processing method provided by the embodiments of the present application is generally executed by server 505. Correspondingly, the crash information processing device is generally set in server 505.

[0112] It should be understood that Figure 5 the numbers of the terminal devices, networks, and servers in

[0113] are merely illustrative. According to the implementation requirements, there can be any number of terminal devices, networks, and servers. Figure 6 which shows a schematic structural diagram of a computer system 600 of a terminal device suitable for implementing the embodiments of the present application. Figure 6 The shown terminal device is merely an example and should not impose any limitation on the functions and usage scope of the embodiments of the present application.

[0114] As Figure 6As shown, computer system 600 includes a central processing unit (CPU) 601, which can perform various appropriate actions and processes according to a program stored in a read-only memory (ROM) 602 or a program loaded from a storage section 608 into a random access memory (RAM) 603. In the RAM 603, various programs and data required for the operation of the computer system 600 are also stored. The CPU 601, ROM 602, and RAM 603 are connected to each other via a bus 604. An input / output (I / O) interface 605 is also connected to the bus 604.

[0115] The following components are connected to the I / O interface 605: an input section 606 including a keyboard, a mouse, etc.; an output section 607 including, for example, a cathode ray tube (CRT), a liquid crystal display (LCD), etc. and a speaker, etc.; a storage section 608 including a hard disk, etc.; and a communication section 609 including a network interface card such as a LAN card, a modem, etc. The communication section 609 performs communication processing via a network such as the Internet. A drive 610 is also connected to the I / O interface 605 as needed. A removable medium 611, such as a magnetic disk, an optical disk, a magneto-optical disk, a semiconductor memory, etc., is installed on the drive 610 as needed so that a computer program read from it can be installed into the storage section 608 as needed.

[0116] In particular, according to the embodiments disclosed in the present application, the processes described above with reference to the flowcharts can be implemented as computer software programs. For example, the embodiments disclosed in the present application include a computer program product, which includes a computer program carried on a computer-readable medium, and the computer program contains program codes for performing the methods shown in the flowcharts. In such an embodiment, the computer program can be downloaded and installed from a network via the communication section 609, and / or installed from the removable medium 611. When the computer program is executed by the central processing unit (CPU) 601, the above functions defined in the system of the present application are executed.

[0117] It should be noted that the computer-readable medium shown in this application can be a computer-readable signal medium, a computer-readable storage medium, or any combination of the two. A computer-readable storage medium can be, for example, but not limited to, an electrical, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any combination of the above. More specific examples of a computer-readable storage medium can include, but are not limited to: an electrical connection with one or more wires, a portable computer disk, a hard disk, a random access memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or flash memory), an optical fiber, a portable compact disk read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the above. In this application, a computer-readable storage medium can be any tangible medium that contains or stores a program, which can be used by or in conjunction with an instruction execution system, apparatus, or device. And in this application, a computer-readable signal medium can include a data signal propagated in a baseband or as part of a carrier wave, which carries computer-readable program code. Such a propagated data signal can take various forms, including but not limited to electromagnetic signals, optical signals, or any suitable combination of the above. A computer-readable signal medium can also be any computer-readable medium other than a computer-readable storage medium, which can send, propagate, or transmit a program for use by or in conjunction with an instruction execution system, apparatus, or device. The program code contained on a computer-readable medium can be transmitted using any appropriate medium, including but not limited to: wireless, wire, optical cable, RF, etc., or any suitable combination of the above.

[0118] The flowcharts and block diagrams in the accompanying drawings illustrate the possible architectures, functions, and operations of systems, methods, and computer program products according to various embodiments of this application. In this regard, each block in a flowchart or block diagram can represent a module, a program segment, or a part of code, and the above module, program segment, or part of code contains one or more executable instructions for implementing a specified logical function. It should also be noted that in some alternative implementations, the functions marked in the blocks can occur in a different order than that marked in the accompanying drawings. For example, two consecutive blocks shown can actually be executed substantially in parallel, and they can sometimes be executed in the reverse order, depending on the functions involved. It should also be noted that each block in the block diagram or flowchart, as well as the combination of blocks in the block diagram or flowchart, can be implemented by a dedicated hardware-based system for performing the specified functions or operations, or can be implemented by a combination of dedicated hardware and computer instructions.

[0119] The units involved in the embodiments described in this application can be implemented in software or in hardware. The described units can also be provided in a processor. For example, it can be described as: a processor includes a receiving unit, a crash handling node determination unit, and a sending unit. Among them, the names of these units do not, in some cases, limit the unit itself.

[0120] As another aspect, this application also provides a computer-readable medium. The computer-readable medium can be included in the device described in the above embodiments; it can also exist alone without being assembled into the device. The above computer-readable medium carries one or more programs. When the one or more programs are executed by such a device, the device receives program crash information, obtains the crash file name in the program crash information, and then determines the crash version branch information, and obtains the corresponding information summary set from the system configuration file through the crash version branch information; matches the crash file name with all the information summaries in the information summary set to determine the crash handling node corresponding to the crash file name; and sends the program crash information to the crash handling node.

[0121] According to the technical solution of the embodiments of this application, through the crash file name in the recognizable program crash information parsed according to the received symbol table file, the crash version branch information can be quickly located. And based on the crash version branch information, the corresponding information summary set is obtained, and the crash file name is matched with all the information summaries in the information summary set to achieve quickly locating the crash handling node corresponding to the crash file name. The crash handling node can be understood as the person responsible for submitting the crash version branch information. Thus, by sending the program crash information to the crash handling node, the program crash information can be timely notified to the relevant responsible person, quickly responding to handle the program crash problem and avoiding the expansion of the problem.

[0122] The above specific implementation manners do not constitute a limitation to the protection scope of this application. Those skilled in the art should understand that various modifications, combinations, sub-combinations, and substitutions can occur depending on design requirements and other factors. Any modifications, equivalent substitutions, and improvements made within the spirit and principle of this application shall be included within the protection scope of this application.

Claims

1. A method for processing crash information, characterized in that, Including: Receiving program crash information, obtaining the crash file name in the program crash information, and then determining the crash version branch information, and obtaining the corresponding information summary set from the system configuration file through the crash version branch information; wherein, the obtaining the corresponding information summary set includes: calling a preset script code to obtain the version branch commit record corresponding to the crash version branch information from the system configuration file; and obtaining the information summary set corresponding to the crash version branch information from the version branch commit record; Matching the crash file name with all information summaries in the information summary set to determine the crash handling node corresponding to the crash file name; wherein, the determining the crash handling node corresponding to the crash file name includes: obtaining the modified file information set corresponding to the information summary set, and then determining the modified file name set corresponding to the modified file information set; arranging the version branch commit record in reverse order, and then matching all modified file names in the modified file name set with the crash file name according to the reverse-ordered version branch commit record to determine the modified file name corresponding to the crash file name; and determining the crash handling node corresponding to the crash file name according to the modified file name corresponding to the crash file name and the corresponding relationship between the preset modified file name and the crash handling node in the information summary set; Sending the program crash information to the crash handling node.

2. The method according to claim 1, characterized in that, The determining the crash version branch information includes: In response to determining that there is a matching crash module for the crash file name, determining the matching crash module as the program crash module corresponding to the program crash information; Obtaining the crash version branch information corresponding to the program crash module.

3. The method according to claim 1, characterized in that, Before the matching the crash file name with all information summaries in the information summary set, the method further includes: In response to determining that no crash version branch information is determined, calling a preset script code to obtain the version branch commit record corresponding to the version branch information of all modules from the system configuration file; Obtaining the information summary set corresponding to all version branch information from the version branch commit record.

4. A crash information processing device, characterized in that, Including: A receiving unit, configured to receive program crash information, obtain the crash file name in the program crash information, and then determine the crash version branch information, and obtain the corresponding information summary set from the system configuration file through the crash version branch information; wherein, the obtaining the corresponding information summary set includes: calling a preset script code to obtain the version branch commit record corresponding to the crash version branch information from the system configuration file; and obtaining the information summary set corresponding to the crash version branch information from the version branch commit record; A crash handling node determination unit, configured to match the crash file name with all the information digests in the information digest set to determine the crash handling node corresponding to the crash file name; wherein, determining the crash handling node corresponding to the crash file name includes: obtaining the modified file information set corresponding to the information digest set, and then determining the modified file name set corresponding to the modified file information set; arranging the version branch commit records in reverse order, and then according to the version branch commit records arranged in reverse order, matching all the modified file names in the modified file name set with the crash file name to determine the modified file name corresponding to the crash file name; determining the crash handling node corresponding to the crash file name according to the modified file name corresponding to the crash file name and the corresponding relationship between the preset modified file name and the crash handling node in the information digest set; A sending unit, configured to send the program crash information to the crash handling node.

5. The device according to claim 4, characterized in that, The receiving unit is further configured to: In response to determining that there is a matching crash module for the crash file name, determining the matching crash module as the program crash module corresponding to the program crash information; Obtaining the crash version branch information corresponding to the program crash module.

6. The device according to claim 4, characterized in that, The receiving unit is further configured to: In response to determining that no crash version branch information is determined, calling a preset script code to obtain the version branch commit records corresponding to the version branch information of all modules from the system configuration file; Obtaining the information digest set corresponding to all the version branch information from the version branch commit records.

7. A crash information processing electronic device, characterized in that, Includes: One or more processors; A storage device for storing one or more programs, When the one or more programs are executed by the one or more processors, enabling the one or more processors to implement the method according to any one of claims 1-3.

8. A computer-readable medium having a computer program stored thereon, characterized in that, The program, when executed by a processor, implements the method according to any one of claims 1-3.

Images