CN111831544A

CN111831544A - Application program debugging method, device, equipment and storage medium

Info

Publication number: CN111831544A
Application number: CN201910745765.0A
Authority: CN
Inventors: 廖银; 李�根; 吴俊�
Original assignee: Beijing Didi Infinity Technology and Development Co Ltd
Current assignee: Beijing Didi Infinity Technology and Development Co Ltd
Priority date: 2019-08-13
Filing date: 2019-08-13
Publication date: 2020-10-27

Abstract

The application provides a debugging method, a debugging device, equipment and a storage medium of an application program, wherein the method comprises the following steps: receiving a debugging request of a function to be debugged, which is sent by front-end equipment; generating a debugging identifier corresponding to the debugging request; adding the debugging identification in a calling log of a plurality of calling paths, wherein the calling paths are a plurality of paths for realizing the function to be debugged; and returning a debugging result and the debugging identifier to the front-end equipment, wherein the debugging result comprises: a call log of a plurality of the call paths. According to the method and the device, the corresponding debugging identification is generated for the debugging request, the debugging identification is added in the calling logs of the calling paths, the debugging result and the debugging identification are returned to the front-end equipment, confusion among information of different calling paths in the calling logs can be effectively avoided, the difficulty of function debugging and problem positioning is simplified, and the efficiency of function debugging and problem positioning is improved with accuracy.

Description

Application program debugging method, device, equipment and storage medium

Technical Field

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

Background

With the development of internet technology, more and more application programs are developed by adopting a front-end and back-end separation architecture. For an application program developed by a 'front-end and back-end separation' architecture, front-end and back-end joint debugging is inevitable.

In the development process of the application program or under the condition that the function of the application program is inconsistent with the preset function in the application process, the function joint debugging with the back end is required to realize the function debugging and the problem positioning. Currently, a front-end device can obtain a call log from a back-end device, and then function debugging and problem location are performed according to the call log.

However, the information of different call paths in the call log is easily confused, which undoubtedly brings difficulties to function debugging and problem location.

Disclosure of Invention

In view of the above, an object of the present application is to provide a method, an apparatus, a device, and a storage medium for debugging an application program, which can avoid confusion between information of different call paths in a call log, and simplify difficulty of function debugging and problem location.

In one aspect of the present application, there is provided a method for debugging an application program, including:

receiving a debugging request of a function to be debugged, which is sent by front-end equipment;

generating a debugging identifier corresponding to the debugging request;

adding the debugging identification in a calling log of a plurality of calling paths, wherein the calling paths are a plurality of paths for realizing the function to be debugged;

and returning a debugging result and the debugging identifier to the front-end equipment, wherein the debugging result comprises: the call log.

In some embodiments, generating the debug identifier corresponding to the debug request may include:

and randomly generating an identifier as a debugging identifier corresponding to the debugging request.

In other embodiments, the debug identifier is a universally unique identifier UUID.

In still other embodiments, the debug request comprises: information of the access interface of the function to be debugged;

the multiple paths for realizing the function to be debugged are multiple paths for calling the access interface.

In another aspect of the present application, there is also provided a method for debugging an application program, including:

sending a debugging request of a function to be debugged to back-end equipment; the debugging request is used for enabling the back-end equipment to generate a debugging identifier corresponding to the debugging request, and the debugging identifier is added into a calling log of a plurality of calling paths, wherein the calling paths are a plurality of paths for realizing the function to be debugged;

receiving a debugging result returned by the back-end equipment and the debugging identification, wherein the debugging result comprises: the call log.

In some embodiments, the commissioning identifier is an identifier randomly generated by the backend device.

In other embodiments, the debug request comprises: information of the access interface of the function to be debugged;

In another aspect of the present application, there is also provided a debugging apparatus for an application program, including:

the system comprises a receiving module, a debugging module and a debugging module, wherein the receiving module is used for receiving a debugging request of a function to be debugged, which is sent by front-end equipment;

the processing module is used for generating a debugging identifier corresponding to the debugging request; adding the debugging identification in a calling log of a plurality of calling paths, wherein the calling paths are a plurality of paths for realizing the function to be debugged;

a sending module, configured to return a debugging result and the debugging identifier to the front-end device, where the debugging result includes: a call log of a plurality of the call paths.

In still another aspect of the present application, there is provided a debugging apparatus for an application program, including:

the sending module is used for sending a debugging request of a function to be debugged to the back-end equipment; the debugging request is used for enabling the back-end equipment to generate a debugging identifier corresponding to the debugging request, and the debugging identifier is added into a calling log of a plurality of calling paths, wherein the calling paths are a plurality of paths for realizing the function to be debugged;

a receiving module, configured to receive a debugging result returned by the backend device and the debugging identifier, where the debugging result includes: a call log of a plurality of the call paths.

In yet another aspect of the present application, there is also provided a back-end device, which may include a processor, a storage medium, and a bus. The storage medium stores machine-readable instructions executable by the processor. When the electronic device runs, the processor and the storage medium communicate through the bus, and the processor executes the machine readable instructions to execute the debugging method of the application program provided by the above aspect.

In yet another aspect of the present application, there is also provided a front-end apparatus, including: the device comprises a processor, a storage medium and a bus, wherein the storage medium stores machine-readable instructions executable by the processor, when the electronic device runs, the processor and the storage medium communicate through the bus, and the processor executes the machine-readable instructions to execute the debugging method of the application program provided by the other aspect.

In yet another aspect of the present application, there may also be provided a computer-readable storage medium having stored thereon a computer program which, when executed by a processor, performs the debugging method of the application program as provided in the above one aspect.

In yet another aspect of the present application, there may be further provided a computer-readable storage medium having a computer program stored thereon, the computer program being executed by a processor to perform the debugging method of the application program provided in the above another aspect.

Based on any aspect, the back-end device can generate a corresponding debugging identifier for the debugging request, and in the process of debugging based on the debugging request, the debugging identifier is added to the call logs of the multiple call paths, and the debugging identifier is returned to the front-end device under the condition that a debugging result is returned to the front-end device, so that the front-end device can quickly determine a debugging request initiated by the front-end device based on the debugging logs and the debugging identifier in the returned debugging result, realize problem location and achieve function joint debugging; moreover, debugging marks are added in the call logs of the multiple call paths, confusion among information of different call paths in the call logs can be effectively avoided, difficulty of function debugging and problem positioning is simplified, and efficiency and accuracy of the function debugging and the problem positioning are improved.

In addition, in some embodiments, a randomly generated identifier, such as a UUID, is used as the debugging identifier corresponding to the debugging request, so that the unique correspondence between the debugging request and the debugging identifier is improved, the debugging identifier is prevented from being mistakenly overlapped, confusion among information of different calling paths in the call log is effectively avoided, the difficulty of function debugging and problem positioning is effectively simplified and simplified, and the efficiency and accuracy of function debugging and problem positioning are ensured.

Drawings

In order to more clearly illustrate the technical solutions of the embodiments of the present application, the drawings that are required to be used in the embodiments will be briefly described below, it should be understood that the following drawings only illustrate some embodiments of the present application and therefore should not be considered as limiting the scope, and for those skilled in the art, other related drawings can be obtained from the drawings without inventive effort.

Fig. 1 is a schematic diagram of a debugging system applied in a debugging method of an application program according to an embodiment of the present application;

fig. 2 is an interaction flowchart of a debugging method of an application program according to an embodiment of the present application;

fig. 3 is a schematic diagram of a debugging apparatus for an application according to an embodiment of the present application;

fig. 4 is a schematic diagram of another debugging apparatus for an application according to an embodiment of the present application;

fig. 5 is a schematic structural diagram of a backend device according to an embodiment of the present application;

fig. 6 is a schematic structural diagram of a front-end device according to an embodiment of the present application.

Detailed Description

In order to make the purpose, technical solutions and advantages of the embodiments of the present application clearer, the technical solutions in the embodiments of the present application will be clearly and completely described below with reference to the drawings in the embodiments of the present application, and it should be understood that the drawings in the present application are for illustrative and descriptive purposes only and are not used to limit the scope of protection of the present application. Additionally, it should be understood that the schematic drawings are not necessarily drawn to scale. The flowcharts used in this application illustrate operations implemented according to some embodiments of the present application. It should be understood that the operations of the flow diagrams may be performed out of order, and steps without logical context may be performed in reverse order or simultaneously. One skilled in the art, under the guidance of this application, may add one or more other operations to, or remove one or more operations from, the flowchart.

In addition, the described embodiments are only a part of the embodiments of the present application, and not all of the embodiments. The components of the embodiments of the present application, generally described and illustrated in the figures herein, can be arranged and designed in a wide variety of different configurations. Thus, the following detailed description of the embodiments of the present application, presented in the accompanying drawings, is not intended to limit the scope of the claimed application, but is merely representative of selected embodiments of the application. All other embodiments, which can be derived by a person skilled in the art from the embodiments of the present application without making any creative effort, shall fall within the protection scope of the present application.

It should be noted that in the embodiments of the present application, the term "comprising" is used to indicate the presence of the features stated hereinafter, but does not exclude the addition of further features.

Fig. 1 is a schematic diagram of a debugging system to which the debugging method of the application program provided in the following embodiments of the present application is applied. The debugging system may also be referred to as a front-end and back-end joint debugging system, as shown in fig. 1, which may include: a front-end device 101 and a back-end device 102. The front-end device 101 and the back-end device 102 may be connected by wire or wirelessly.

The debugging system can be used for carrying out function debugging on the application program in the development process of the application program, and can also be used for carrying out function debugging on the application program under the condition that the function is inconsistent with the preset function in the application process of the application program.

The application may be a front-end application, and the front-end device 101 may be a front-end debugging device, which may be a device for installing and running the front-end application, such as a front-end debugging terminal or a front-end debugging server for installing and running the front-end application. The front-end debugging terminal may be, for example, a terminal device such as a notebook computer, a desktop computer, a smart phone, a tablet computer, and the like, which can be installed and run a front-end application program. The front-end application may be a front-end user-oriented application, which may be a browser version or a Web (Web) version application, or a client application. If a client application, the front-end device 101 may also be referred to as a client device of the application.

The backend device 102 may be a backend debugging device, which may be a device that installs and runs a backend application, such as a backend debugging terminal or a backend debugging server that installs and runs a backend application. The back-end application program may be a back-end processing application program corresponding to the front-end application program. The backend application may be an application program facing backend data processing, and may be an application program of a server corresponding to the front-end application program. Thus, the backend device 102 may also be referred to as a server device for an application, or an application server for an application.

It should be noted that the application programs referred to in the present application may be any type of application programs such as a service type application program, a music type application program, a game type application program, an image type application program, a video type application program, a communication type application program, an online transaction platform, and the like. The service application program can be a program capable of providing services, and the services can be transportation services such as taxi, designated driving service, express bus, car sharing, bus service, driver leasing, or regular bus service, or online transportation services of any combination of the transportation services; and can also be used for information inquiry services such as house source inquiry, data inquiry and the like. Of course, other types of services are possible, and the above is only a possible example, and the application is not limited thereto.

Since the application program related to the present application is an application program with a "front-end and back-end separation" architecture, the method for debugging an application program provided in the following embodiments of the present application is actually a front-end and back-end function joint debugging method. By executing the debugging method of the application program, the function debugging can be carried out on the application program so as to determine whether the application program can realize the preset function, and if the application program can not realize the preset function or the realized function is inconsistent with the preset function, the problem positioning can be carried out on the function fault of the application program, and the like.

It should be noted that before the application is filed, the front-end device can only obtain the call log generated by the front-end device from the back-end device, and information of different call paths in the call log is easily confused, which undoubtedly brings difficulties to function debugging and problem location. Therefore, the embodiments of the present application provide the following debugging methods, so that the information of each path in the call log has a debugging identifier corresponding to the debugging request, and the front-end device can also obtain the modulation identifier when obtaining the debugging result including the call log, thereby effectively avoiding confusion of information of different paths in the call log, and facilitating function debugging and problem location.

The application program debugging method provided by the present application is explained below by way of example with reference to the accompanying drawings. Fig. 2 is an interaction flowchart of a debugging method of an application program according to an embodiment of the present application. The method shown in fig. 2 may be implemented by the front-end device 101 and the back-end device 102 in the debugging system shown in fig. 1. As shown in fig. 2, the debugging method of the application program may include:

s201, the front-end equipment sends a debugging request of a function to be debugged to the back-end equipment.

The front-end equipment can trigger to send the debugging request to the back-end equipment corresponding to the debugging instruction under the condition of receiving the debugging instruction of the function to be debugged input by the user. The function to be debugged may be any type of function such as an interactive function, a display function, a business function, and the like of the application program. The debugging instruction of the function to be debugged can be a debugging instruction input by a user through clicking a debugging button on an interface, or can also receive the modulation instruction transmitted by the user through other equipment. The interface clicked by the user can be a preset debugging interface or an application interface of the application program.

The debug request may include: and the information is used for representing the function to be debugged and informing the front-end equipment that the debugging request is the debugging request of the function to be debugged. In order to enable the back-end device to perform function debugging based on the received debugging request, the debugging request may further include information such as debugging parameters of the function to be debugged, so that the back-end device may perform debugging of the function to be debugged based on the debugging parameters.

Correspondingly, the method can further comprise the following steps:

and the back-end equipment receives the debugging request sent by the front-end equipment.

Optionally, the debugging request may further include: and requesting interface information, and after the back-end equipment receives the debugging request, determining that the received message is the debugging request based on the request interface. The request Interface is information of a predetermined request entry, which may be an Application Program Interface (API) of the request entry, and the API of the request entry may be, for example, a Uniform Resource Locator (URL) address corresponding to the request entry on the backend device.

And S202, the back-end equipment generates a debugging identifier corresponding to the debugging request.

The back-end device may generate an identifier as a debug identifier corresponding to the debug request, when receiving the debug request. The debug identifier may be used to uniquely identify a debug action corresponding to the debug request, which may uniquely correspond to a debug request.

When the back-end device receives a debugging request, the back-end device can correspond to a debugging behavior, and then the back-end device needs to generate an identifier as a debugging identifier corresponding to the debugging request. In the scheme of the application, the debugging identification generated by the back-end equipment can be different no matter the debugging request is directed to different functions or multiple debugging requests are directed to the same function.

Optionally, in an embodiment, as shown above, the generating, by the backend device in S202, a debug identifier corresponding to the debug request may include:

and the back-end equipment randomly generates an identifier as a debugging identifier corresponding to the debugging request.

In the method, the back-end equipment can adopt a preset random identifier generator to randomly generate an identifier as a debugging identifier corresponding to the debugging request; or a random number generator is adopted to generate a random number, the random number is combined with the information in the debugging request to obtain a random identifier, and the random identifier is used as the debugging identifier corresponding to the debugging request; and generating a random number by adopting a random number generator, generating an identifier by adopting a preset identifier generation algorithm, combining the random number and the identifier to obtain a random identifier, and then using the random identifier as the debugging identifier corresponding to the debugging request.

Alternatively, the debug identifier may be a Universal Unique Identifier (UUID) as shown above. Accordingly, the random identifier generator as shown above may be, for example, a UUID random generator.

In some other embodiments, the back-end device may further use another identifier generation algorithm to generate a debugging identifier corresponding to the debugging request, as long as the generated identifier can identify the debugging request.

And S203, the back-end equipment adds the debugging identifier in the calling logs of a plurality of calling paths, wherein the calling paths are a plurality of paths for realizing the function to be debugged.

And the back-end equipment can debug a plurality of call paths for realizing the function to be debugged according to the debugging parameters or preset debugging parameters included in the debugging request under the condition of receiving the debugging request, so as to realize the debugging of the function to be debugged. The back-end equipment can generate a call log of each call path in the process of debugging the plurality of call paths.

In a possible implementation manner, the back-end device may add the debugging identifier corresponding to the debugging request generated in the foregoing S202 to the call log of each call path while generating the call log of each call path, or after generating the call log of each call path.

In another possible implementation manner, the back-end device may further output a call log, also referred to as printing, after generating each call path, and add the debug identifier to the call log of each call path when outputting the call log of each call path.

It should be noted that the back-end device may also adopt other manners, and in other possible implementation scenarios, the debug identifier is added to the call logs of the multiple call paths, which is not described herein again. After the debug identifier is added, the call log of each call path may at least include, in addition to the debug identifier: the calling information of each calling path is the calling information recorded by the calling log.

The multiple call paths shown above are multiple paths for implementing the function to be debugged, and may include: and realizing all paths of the function to be debugged, or realizing preset critical paths in all paths of the function to be debugged.

Optionally, the debugging request shown above may further include: and the information of the access interface of the function to be debugged. The access interface of the function to be debugged may be an API corresponding to the function to be debugged, and may be a URL address of the function to be debugged on the backend device. Correspondingly, the multiple paths for realizing the function to be debugged are the multiple paths for calling the access interface, namely the multiple access paths of the access interface.

S204, the back-end device returns a debugging result and the debugging identifier to the front-end device, where the debugging result may include: a call log of multiple call paths.

Correspondingly, the front-end device receives the debugging result and the debugging identification sent by the back-end device.

In one example, after receiving the debugging result and the debugging identifier, the front-end device may display the debugging result and the debugging identifier, so as to display the debugging result and the debugging identifier to a user; and the debugging result and the debugging identification can also be sent to a display device connected with the front-end device for displaying, and the debugging result and the debugging identification are displayed to a user through the display device. The display device may be, for example, a display externally connected to the front-end device, or a terminal device connected to the front-end device.

No matter which way is adopted, the debugging result and the debugging identification are displayed to the user, so that one-time debugging request initiated by the front-end equipment can be quickly determined based on the debugging identification and the debugging log, the problem location is realized, and the function joint debugging is achieved.

In another example, after receiving the debugging result and the debugging identifier, the front-end device can directly determine a debugging request initiated by the front-end device according to the debugging identifier and the debugging log, so as to locate a problem and achieve function joint debugging.

According to the application program debugging method provided by the embodiment of the application program, the back-end equipment can generate a corresponding debugging identifier for each debugging request, the debugging identifier is added to the call logs of the multiple call paths in the debugging process based on the debugging request, and the debugging identifier is returned to the front-end equipment under the condition that the debugging result is returned to the front-end equipment, so that the debugging log and the debugging identifier in the returned debugging result based on the front-end equipment can quickly determine the one-time debugging request initiated by the front-end equipment, the problem location is realized, and the function joint debugging is achieved; moreover, debugging marks are added in the call logs of the multiple call paths, confusion among information of different call intersections in the call logs can be effectively avoided, difficulty of function debugging and problem positioning is simplified, and efficiency and accuracy of the function debugging and the problem positioning are improved.

Based on the same inventive concept, a debugging device corresponding to the debugging method of the application program is also provided in the embodiments of the present application, and because the principle of solving the problem of the device in the embodiments of the present application is similar to the debugging method in the embodiments of the present application, the implementation of the device can refer to the implementation of the method, and repeated details are not repeated.

Fig. 3 is a schematic diagram of a debugging apparatus for an application according to an embodiment of the present application. Each module in the debugging apparatus shown in fig. 3 may be configured to execute a step flow corresponding to the back-end device execution method in the debugging method. As shown in fig. 3, the debugging apparatus of the application program may include: a receiving module 301, a processing module 302 and a sending module 303.

The receiving module 301 is configured to receive a debugging request of a function to be debugged, where the debugging request is sent by a front-end device.

A processing module 302, configured to generate a debugging identifier corresponding to the debugging request; and adding the debugging identification in the call logs of a plurality of call paths, wherein the plurality of call paths are a plurality of paths for realizing the function to be debugged.

A sending module 303, configured to return a debugging result and the debugging identifier to the front-end device, where the debugging result includes: a call log of a plurality of the call paths.

In a possible implementation manner, the processing module 302 is specifically configured to randomly generate an identifier as a debugging identifier corresponding to the debugging request.

In one possible implementation, the debug identification as shown above is a UUID.

In one possible implementation, the debug request as shown above includes: information of the access interface of the function to be debugged; the multiple paths for realizing the function to be debugged are multiple paths for calling the access interface.

Optionally, in this embodiment of the application, the processing module 302 may further perform other processing operations of the backend device, which is specifically referred to above and is not described herein again.

In the embodiment of the present application, the method flow executed by the back-end device, the processing flow of each module, the description of the interaction flow between each module, and the corresponding technical effects in the debugging method can be executed by referring to the relevant description in the above method embodiment, and detailed description is not repeated here.

Fig. 4 is a schematic diagram of another debugging apparatus for an application according to an embodiment of the present application. Each module in the debugging apparatus shown in fig. 4 may be configured to execute a step flow corresponding to a front-end device execution method in the debugging method. As shown in fig. 4, the debugging apparatus of the application program may include: a sending module 401 and a receiving module 402.

The sending module 401 is configured to send a debugging request of a function to be debugged to the backend device; the debugging request is used for enabling the back-end equipment to generate a debugging identifier corresponding to the debugging request, and the debugging identifier is added into a calling log of a plurality of calling paths, wherein the calling paths are a plurality of paths for realizing the function to be debugged;

a receiving module 402, configured to receive a debugging result and the debugging identifier returned by the backend device, where the debugging result includes: a call log of a plurality of the call paths.

In one possible implementation, the debug identifier as shown above is an identifier randomly generated by the backend device. For example, the debug identification may be a UUID.

In the embodiment of the present application, the method flow executed by the front-end device, the processing flow of each module, the description of the interaction flow between each module, and the corresponding technical effects in the debugging method can be executed by referring to the relevant description in the above method embodiment, and detailed description is not repeated here.

The embodiment of the application also provides the back-end equipment. Fig. 5 is a schematic structural diagram of a backend device according to an embodiment of the present application. The back-end device can be used for executing the step flows corresponding to the debugging method in the debugging method. As shown in fig. 5, the backend apparatus 50 includes: a processor 51, a memory 52, and a bus 53. The memory 52 stores machine-readable instructions executable by the processor 51 (for example, execution instructions corresponding to the receiving module 301, the processing module 302, and the sending module 303 in the apparatus shown in fig. 3, and the like), when the backend device 50 runs, the processor 51 communicates with the memory 52 through the bus 53, and the machine-readable instructions, when executed by the processor 51, perform the following processes:

generating a debugging identifier corresponding to the debugging request; adding the debugging identification in a calling log of a plurality of calling paths, wherein the calling paths are a plurality of paths for realizing the function to be debugged;

and returning a debugging result and the debugging identifier to the front-end equipment, wherein the debugging result comprises: a call log of a plurality of the call paths.

In a possible implementation manner, the instructions executed by the processor 51 may further include: and the execution instruction is used for randomly generating an identifier as a debugging identifier corresponding to the debugging request.

In a possible embodiment, the backend device 50 further comprises: a transmitter and a receiver; the transmitter and receiver are each connected to the processor 51 by a bus 53.

The processor 51 can control the transmitter to execute the transmitting action of the back-end equipment in the method by calling the instruction corresponding to the transmitting module; the processor 51 may also control the receiver to execute the receiving action of the backend device in the above method by calling the instruction corresponding to the receiving module.

The embodiment of the present application further provides a computer-readable storage medium, where a computer program is stored on the computer-readable storage medium, and when the computer program is executed by a processor, the method steps executed by a back-end device in the debugging method of the application program are executed.

Specifically, the storage medium can be a general-purpose storage medium, such as a mobile disk, a hard disk, and the like, and when a computer program on the storage medium is run, a method executed by a back-end device in the debugging method of the application program can be executed, so that problems of function joint debugging and problem location at the front end and the back end are solved, difficulty of function debugging and problem location is simplified, and efficiency and accuracy of function debugging and problem location are improved.

The embodiment of the application also provides front-end equipment. Fig. 6 is a schematic structural diagram of a front-end device according to an embodiment of the present application. The front-end device can be used for executing the step flows corresponding to the front-end device executing method in the debugging method. As shown in fig. 6, the front-end apparatus 60 includes: a processor 61, a memory 62, and a bus 63. The memory 62 stores machine-readable instructions executable by the processor 61 (for example, the execution instructions corresponding to the sending module 401 and the receiving module 402 in the apparatus in fig. 4, and the like), when the front-end device 60 runs, the processor 61 communicates with the memory 62 through the bus 63, and when the machine-readable instructions are executed by the processor 61, the following processes are performed:

receiving a debugging result and the debugging identification returned by the back-end equipment, wherein the debugging result comprises: a call log of a plurality of the call paths.

In a possible embodiment, the front-end device 60 further comprises: a transmitter and a receiver; the transmitter and receiver are each connected to the processor 61 via a bus 63.

The processor 61 can control the transmitter to execute the transmitting action of the front-end equipment in the method by calling the instruction corresponding to the transmitting module; the processor 61 may also control the receiver to execute the receiving action of the front-end device in the above method by calling the instruction corresponding to the receiving module.

The embodiment of the present application further provides a computer-readable storage medium, where a computer program is stored on the computer-readable storage medium, and when the computer program is executed by a processor, the method steps executed by a front-end device in the debugging method of the application program are executed.

Specifically, the storage medium can be a general-purpose storage medium, such as a mobile disk, a hard disk, and the like, and when a computer program on the storage medium is run, a method executed by a front-end device in the debugging method of the application program can be executed, so that problems of function joint debugging and problem location at the front end and the back end are solved, difficulty of function debugging and problem location is simplified, and efficiency and accuracy of function debugging and problem location are improved.

In some embodiments, a processor may include one or more processing cores (e.g., a single core processor (S) or a multi-core processor (S)) in a front end device or a back end device as shown above. Merely by way of example, a Processor may include a Central Processing Unit (CPU), an Application Specific Integrated Circuit (ASIC), an Application Specific Instruction Set Processor (ASIP), a Graphics Processing Unit (GPU), a Physical Processing Unit (PPU), a Digital Signal Processor (DSP), a Field Programmable Gate Array (FPGA), a Programmable Logic Device (PLD), a controller, a microcontroller Unit, a reduced Instruction Set computer (reduced Instruction Set computer), a microprocessor, or the like, or any combination thereof.

It can be clearly understood by those skilled in the art that, for convenience and brevity of description, the specific working processes of the system and the apparatus described above may refer to corresponding processes in the method embodiments, and are not described in detail in this application. In the several embodiments provided in the present application, it should be understood that the disclosed system, apparatus and method may be implemented in other ways. The above-described apparatus embodiments are merely illustrative, and for example, the division of the modules is merely a logical division, and there may be other divisions in actual implementation, and for example, a plurality of modules or components may be combined or integrated into another system, or some features may be omitted, or not executed. In addition, the shown or discussed mutual coupling or direct coupling or communication connection may be an indirect coupling or communication connection of devices or modules through some communication interfaces, and may be in an electrical, mechanical or other form.

The modules described as separate parts may or may not be physically separate, and parts displayed as modules may or may not be physical units, may be located in one place, or may be distributed on a plurality of network units. Some or all of the units can be selected according to actual needs to achieve the purpose of the solution of the embodiment.

In addition, functional units in the embodiments of the present application may be integrated into one processing unit, or each unit may exist alone physically, or two or more units are integrated into one unit.

The functions, if implemented in the form of software functional units and sold or used as a stand-alone product, may be stored in a non-volatile computer-readable storage medium executable by a processor. Based on such understanding, the technical solution of the present application or portions thereof that substantially contribute to the prior art may be embodied in the form of a software product stored in a storage medium and including instructions for causing a computer device (which may be a personal computer, a server, or a network device) to execute all or part of the steps of the method according to the embodiments of the present application. And the aforementioned storage medium includes: various media capable of storing program codes, such as a U disk, a removable hard disk, a ROM, a RAM, a magnetic disk, or an optical disk.

The above description is only for the specific embodiments of the present application, but the scope of the present application is not limited thereto, and any person skilled in the art can easily conceive of the changes or substitutions within the technical scope of the present application, and shall be covered by the scope of the present application. Therefore, the protection scope of the present application shall be subject to the protection scope of the claims.

Claims

1. A method for debugging an application program, comprising:

generating a debugging identifier corresponding to the debugging request;

2. The method according to claim 1, wherein the generating of the debug identifier corresponding to the debug request includes:

3. The method of claim 2, wherein the debug identifier is a Universally Unique Identifier (UUID).

4. The method of any of claims 1-3, wherein the debug request comprises: information of the access interface of the function to be debugged;

5. A method for debugging an application program, comprising:

receiving a debugging result returned by the back-end equipment and the debugging identification, wherein the debugging result comprises: a call log of a plurality of the call paths.

6. The method of claim 5, wherein the debug identifier is a randomly generated identifier for the backend device.

7. The method of claim 6, wherein the debugging identifier is a Universally Unique Identifier (UUID).

8. The method of any of claims 5-7, wherein the debug request comprises: information of the access interface of the function to be debugged;

9. An apparatus for debugging an application program, comprising:

10. An apparatus for debugging an application program, comprising:

11. A backend device, comprising: a processor, a storage medium and a bus, the storage medium storing machine-readable instructions executable by the processor, the processor and the storage medium communicating via the bus when the electronic device is operating, the processor executing the machine-readable instructions to perform the steps of the method according to any one of claims 1 to 4.

12. A front-end device, comprising: a processor, a storage medium and a bus, the storage medium storing machine-readable instructions executable by the processor, the processor and the storage medium communicating via the bus when the electronic device is operating, the processor executing the machine-readable instructions to perform the steps of the method according to any one of claims 5 to 8.

13. A computer-readable storage medium, having stored thereon a computer program which, when being executed by a processor, is adapted to carry out the steps of the method according to any one of claims 1 to 4.

14. A computer-readable storage medium, having stored thereon a computer program which, when being executed by a processor, is adapted to carry out the steps of the method according to any one of claims 5 to 8.