In C# the executing program can detect if it's running in the debugger using:
System.Diagnostics.Debugger.IsAttached
Is there an equivalent in Go? I have some timeouts which I would like to be disabled while I am stepping through the code. Thanks!
I am using the GoLand debugger.
As far as I know, there is no built-in way to do this in the manner you described. But you can do more or less the same using build tags to indicate that the delve debugger is running. You can pass build tags to dlv with the --build-flags argument. This is basically the same technique as I described in How can I check if the race detector is enabled at runtime?
isdelve/delve.go
// +build delve
package isdelve
const Enabled = true
isdelve/nodelve.go:
// +build !delve
package isdelve
const Enabled = false
a.go:
package main
import (
"isdelve"
"fmt"
)
func main() {
fmt.Println("delve", isdelve.Enabled)
}
In Goland, you can enable this under 'Run/Debug Configurations', by adding the following into 'Go tool arguments:'
-tags=delve
If you are outside of Goland, running go run a.go will report delve false, if you want to run dlv on its own, use
dlv debug --build-flags='-tags=delve' a.go; this will report delve true.
Alternatively, you can use delve's set command to manually set a variable after starting the debugger.
If you assume that the debugger used will be Delve, you can check on the Delve process(es). There are at least two cases to consider (maybe more).
os.Getppid() to get the pid of your parent process, that process will be Delve.os.Getpid(). This relies on the assumption that you're not finding an old Delve, running with an older PID that happens to match yours. (I forget what the rules on on reuse of PIDs by the OS). Note that the os functions used by 1 and 2 are different. One gets the parent PID, the other gets your PID.
Some very basic code to do 1 looks like this:
func isLaunchedByDebugger() bool {
// gops executable must be in the path. See https://github.com/google/gops
gopsOut, err := exec.Command("gops", strconv.Itoa(os.Getppid())).Output()
if err == nil && strings.Contains(string(gopsOut), "\\dlv.exe") {
// our parent process is (probably) the Delve debugger
return true
}
return false
}
On Linux, you can read the /proc/self/status file to retrieve TracerPid field, the PID of debugger if any.
func GetTracerPid() (int, error) {
file, err := os.Open("/proc/self/status")
if err != nil {
return -1, fmt.Errorf("can't open process status file: %w", err)
}
defer file.Close()
for {
var tpid int
num, err := fmt.Fscanf(file, "TracerPid: %d\n", &tpid)
if err == io.EOF {
break
}
if num != 0 {
return tpid, nil
}
}
return -1, errors.New("unknown format of process status file")
}
How to use:
tpid, err := GetTracerPid()
if err != nil {
log.Println("something went wrong", err)
} else if tpid != 0 {
fmt.Println("we're under debugging: tracer_pid", tpid)
} else {
fmt.Println("we're free of tracing")
}
Here is a very simple-minded solution detecting Delve if your process is run by it, not attached afterwards. That's by far the majority use case, at least
package isdebugging
import (
"os"
"github.com/mitchellh/go-ps"
)
// IsDebugging will return true if the process was launched from Delve or the
// gopls language server debugger.
//
// It does not detect situations where a debugger attached after process start.
func IsDebugging() bool {
pid := os.Getppid()
// We loop in case there were intermediary processes like the gopls language server.
for pid != 0 {
switch p, err := ps.FindProcess(pid); {
case err != nil:
return false
case p.Executable() == "dlv":
return true
default:
pid = p.PPid()
}
}
return false
}
For case 2 we can set the program to wait for some signal (SIGUSR1) and attach debugger during this wait.
The code of main.go can be like this:
package main
import (
"os"
"os/signal"
"syscall"
"fmt"
"github.com/my/repo/cmd"
)
const (
waitForSignalEnv = "WAIT_FOR_DEBUGGER"
debuggerPort = "4321"
)
func main() {
// Waiting for debugger attach in case if waitForSignalEnv!=""
if os.Getenv(waitForSignalEnv) != "" {
sigs := make(chan os.Signal, 1)
goOn := make(chan bool, 1)
signal.Notify(sigs, syscall.SIGTERM, syscall.SIGINT, syscall.SIGUSR1)
go func() {
sig := <-sigs
if sig == syscall.SIGUSR1 {
goOn <- true
} else if (sig == syscall.SIGTERM || sig == syscall.SIGINT ){
fmt.Printf("Exiting ...")
os.Exit(0)
}
}()
fmt.Printf("%s env is set, waiting SIGUSR1.\nYou can run remote debug in vscode and attach dlv debugger:\n\n", waitForSignalEnv)
pid := os.Getpid()
fmt.Printf("dlv attach --continue --accept-multiclient --headless --listen=:%s %d\n", debuggerPort, pid)
fmt.Printf("\nLaunch remote debugger in vscode to port %d and then give SIGUSR1 to the process\n", debuggerPort)
fmt.Printf("kill -SIGUSR1 %d\n", pid)
<-goOn
fmt.Printf("Continue ...")
}
cmd.Execute()
}
launch.json of vscode:
{
"name": "myprog-remote-debug",
"type": "go",
"request": "launch",
"remotePath": "${env:GOPATH}/src/github.com/my/repo",
"mode": "remote",
"port": 4321,
"host": "127.0.0.1",
"program": "${env:GOPATH}/src/github.com/my/repo",
"showLog": true,
"trace": "verbose"
}
Explanation: we launch the program with env WAIT_FOR_DEBUGGER=true, for example
export WAIT_FOR_DEBUGGER=true
./myprog -f values.yaml
It will output dlv attach ... command and kill -SIGUSR <pid> :
WAIT_FOR_DEBUGGER env is set, waiting SIGUSR1.
You can run remote debug in vscode and attach dlv debugger:
dlv attach --continue --accept-multiclient --headless --listen=:4321 556127
Launch remote debugger in vscode to port 4321 and then give SIGUSR1 to the process
kill -SIGUSR1 556127
Run the dlv attach ... above
Then go to VS Code and run myprog-remote-debug. Set breakpoints before
Then give him kill -SIGUSR1 556127
and breakpoints will work
