Methods and systems for internally debugging code in an on-demand service environment

Abstract

A remote debug session for a server group is provided. A server group including multiple servers that perform workload sharing receives a request to debug code executed at the server group. The code is executed on behalf of a client of a database associated with the server group. At least one of the servers of the group initiates a debugging session and establishes a communication connection with the client. The server group maintains the connection open with the client for the duration of the debugging session. Subsequent requests related to the debug session can be handled in a number of ways by the server group, and all communication to the client about processing the requests is through the connection.

1 - 19 . (canceled) 
     
     
         20 . A system comprising at least one memory device coupled with one or hardware processors, the system configurable to:
 receive a debugging session request utilizing an application program interface (API) from a client device over a network connection, the debugging session request to debug code executed by the server group;   establish a connection between the server group and the client device to initiate a debugging session between the server group and the client device utilizing the API in response to the debugging session request, the server group to maintain open the connection with the client device for a duration of the debugging session;   enable use of breakpoints via remote debugging utilizing the client device;   maintain state for the debugging session with a resource shared among the server group;   receive service requests via the API; and   distribute the service requests among the server group for processing, wherein each server that processes a request is to communicate via the API to the client device and wherein breakpoint operations are modified to be registered in a same state as the connection, and be connected back to the API.   
     
     
         21 . The system of  claim 20 , wherein the server group is to maintain state for the debugging session by storing state for the debugging session in a shared memory cache shared among the servers of the server group. 
     
     
         22 . The system of  claim 20 , wherein the server group is to further
 set a breakpoint that interrupts only execution of a thread of a server handling execution of the debugging session, and does not interrupt other execution threads in the server group;   wherein the breakpoint is set with an associated timeout, and execution of the thread is resumed and ended if activity on the thread ceases for the length of the timeout.   
     
     
         23 . The system of  claim 20 , wherein the server group is to maintain state for the debugging session by creating a thread associated with the debugging session and a stack associated with the thread, wherein the servers of the server group have access to the thread and the stack. 
     
     
         24 . The system of  claim 20 , wherein a separate debugging stack is created with an associated debugging thread started when the debugging session is initiated. 
     
     
         25 . The system of thread  24 , wherein the debugging thread and associated stack are associated with a debugging session identifier (ID) and state information is to be persisted on the stack. 
     
     
         26 . The system of  claim 20 , wherein the client device further comprises an integrated development environment (IDE) to communicate with the server group through the API. 
     
     
         27 . The system of  claim 26 , wherein the IDE enables use of the breakpoints on the client device. 
     
     
         28 . The system of  claim 20 , wherein the server group further provides a multitenant database environment. 
     
     
         29 . The system of  claim 20 , wherein each server in the server group that processes a request is to communicate via a connection from a first server to the client device. 
     
     
         30 . A non-transitory computer-readable medium having stored thereon instructions that, when executed by one or more processors within a server group, are configurable to cause the one or more processors to:
 receive a debugging session request utilizing an application program interface (API) from a client device over a network connection, the debugging session request to debug code executed by the server group;   establish a connection between the server group and the client device to initiate a debugging session between the server group and the client device utilizing the API in response to the debugging session request, the server group to maintain open the connection with the client device for a duration of the debugging session;   enable use of breakpoints via remote debugging utilizing the client device;   maintain state for the debugging session with a resource shared among the server group;   receive service requests via the API; and   distribute the service requests among the server group for processing, wherein each server that processes a request is to communicate via the API to the client device and wherein breakpoint operations are modified to be registered in a same state as the connection, and be connected back to the API.   
     
     
         31 . The system of  claim 30 , wherein the server group is to maintain state for the debugging session by storing state for the debugging session in a shared memory cache shared among the servers of the server group. 
     
     
         32 . The system of  claim 30 , wherein the server group is to further
 set a breakpoint that interrupts only execution of a thread of a server handling execution of the debugging session, and does not interrupt other execution threads in the server group;   wherein the breakpoint is set with an associated timeout, and execution of the thread is resumed and ended if activity on the thread ceases for the length of the timeout.   
     
     
         33 . The system of  claim 30 , wherein the server group is to maintain state for the debugging session by creating a thread associated with the debugging session and a stack associated with the thread, wherein the servers of the server group have access to the thread and the stack. 
     
     
         34 . The system of  claim 30 , wherein a separate debugging stack is created with an associated debugging thread started when the debugging session is initiated. 
     
     
         35 . The system of thread  34 , wherein the debugging thread and associated stack are associated with a debugging session identifier (ID) and state information is to be persisted on the stack. 
     
     
         36 . The system of  claim 30 , wherein the client device further comprises an integrated development environment (IDE) to communicate with the server group through the API. 
     
     
         37 . The system of  claim 36 , wherein the IDE enables use of the breakpoints on the client device. 
     
     
         38 . The system of  claim 30 , wherein the server group further provides a multitenant database environment. 
     
     
         39 . The system of  claim 30 , wherein each server in the server group that processes a request is to communicate via a connection from a first server to the client device. 
     
     
         40 . A method comprising:
 receiving a debugging session request utilizing an application program interface (API) from a client device over a network connection, the debugging session request to debug code executed by the server group;   establishing a connection between the server group and the client device to initiate a debugging session between the server group and the client device utilizing the API in response to the debugging session request, the server group to maintain open the connection with the client device for a duration of the debugging session;   enabling use of breakpoints via remote debugging utilizing the client device;   maintaining state for the debugging session with a resource shared among the server group;   receiving service requests via the API; and   distributing the service requests among the server group for processing, wherein each server that processes a request is to communicate via the API to the client device and wherein breakpoint operations are modified to be registered in a same state as the connection, and be connected back to the API.   
     
     
         41 . The method of  claim 40 , wherein the server group is to maintain state for the debugging session by storing state for the debugging session in a shared memory cache shared among the servers of the server group. 
     
     
         42 . The method of  claim 40 , further comprising:
 setting a breakpoint that interrupts only execution of a thread of a server handling execution of the debugging session, and does not interrupt other execution threads in the server group;   wherein the breakpoint is set with an associated timeout, and execution of the thread is resumed and ended if activity on the thread ceases for the length of the timeout.   
     
     
         43 . The method of  claim 40 , wherein the server group is to maintain state for the debugging session by creating a thread associated with the debugging session and a stack associated with the thread, wherein the servers of the server group have access to the thread and the stack. 
     
     
         44 . The method of  claim 40 , wherein a separate debugging stack is created with an associated debugging thread started when the debugging session is initiated. 
     
     
         45 . The method of thread  44 , wherein the debugging thread and associated stack are associated with a debugging session identifier (ID) and state information is to be persisted on the stack. 
     
     
         46 . The method of  claim 40 , wherein the client device further comprises an integrated development environment (IDE) to communicate with the server group through the API. 
     
     
         47 . The method of  claim 46 , wherein the IDE enables use of the breakpoints on the client device. 
     
     
         48 . The method of  claim 40 , wherein the server group further provides a multitenant database environment. 
     
     
         49 . The method of  claim 40 , wherein each server in the server group that processes a request is to communicate via a connection from a first server to the client device.