Debug Golang com VSCode
Published: 2023-01-06 19:09:46

Opa, fala aí, pessoal, tudo beleza!? Depois de muito tempo sem escrever algo eu estou aparecendo aqui com esse mini tutorial (ou “how to” como alguns chamam) para explicar como configurar o VSCode para que se possa debugar ao desenvolver em Go (Golang). A minha principal motivação vem da galera com a qual eu trabalho, pois muitos têm dado preferência a utilizar o VSCode para desenvolver e, quando eles precisam de alguma ajuda ou tem alguma dúvida, que eu paro para tentar ajudá-los, eles colocam alguns println para entender o fluxo do sistema e para tentar saber o valor que determinada variável possui e por aí vai. Com isso, acabam repetindo as mesmas ações e outras coisas mais que acabam dificultando o entendimento e a resolver a questão. Como eu sou de uma geração um pouco mais antiga, eu desde cedo fui moldado a utilizar o debug na qual as IDEs disponibilizam e eu achei estranho - até meio improdutivo, isso alinhado a tortura do println - essa galera mais nova adicionar um monte de println ao código e depois sair removendo tudo quando vão realizar o commit.

Bem. Eu já falei (eu quis dizer escrever, mas você entendeu) demais. Vamos ao que interessa!

## Sumário

* Sistema e Configurações
* Pré-Requisitos
	* Instalar Go no VSCode
	* Instalar o DLV no VSCode
* Template básico do arquivo de configuração
* Configurando o projeto
* Inicializando a aplicação no modo debug
* Conclusão
* Referências
* Apêndices

## Sistema e Configurações

-   Pop!_OS versão 22.04 LTS em Máquina Virtual (VM);
-   Go na versão 1.19.4 instalado via GVM;
-   VSCode versão 1.74.1 instalado via flatpak;
    
## Pré-Requisitos

### Instalar Go no VSCode

Para esse tutorial foi utilizado a extensão Go na versão 0.37.0 da empresa *Go team at Google*.

### Instalar o *DLV* no VSCode

Para tirar maior proveito na manutenção e assim manter atualizado o modo debug, pode-se utilizar o *dlv*. O jeito mais fácil de instalar o *dlv* é utilizar o comando "`Go: Install/Update Tools`" na paleta de comando do VSCode (Linux/Windows: Ctrl+Shift+P). O comando mostrará o *dlv* na listagem de ferramentas.

## Template básico do arquivo de configuração

Para usar o modo debug no VSCode será necessário ter na raíz do projeto a pasta `.vscode` e dentro dela o arquivo launch.json, assim ficando `/.vscode/launch.json`.

Exemplo:

    | raíz_projeto
    | - .vscode
    | - - launch.json

A seguir, um template básico do `launch.json`.
    
     {
	    "version": "0.2.0",
	    "configurations": [
		    {
			    "name": "Run Name",
			    "type": "go",
			    "request": "launch",
			    "mode": "debug",
			    "program": "${workspaceFolder}",
			    "env": {},
			    "args": [],
			    "showLog": true
		    }
	    ]
    }

> ${workspaceFolder} é uma variável de ambiente gerada pelo VSCode que corresponde ao diretório raíz da aplicação.

## Configurando o projeto

Para ter um exemplo mais concreto do uso será utilizado um projeto de exemplo como base para demonstrar as configurações.

Estrutura base do projeto:

    | test-debug
    | - .vscode
    | - - launch.json
    | - cmd
    | - - main.go
    | - envfile.env
    | - go.mod

É possível ter mais de uma configuração no mesmo `launch.json` para ser utilizada de acordo com a necessidade, ou seja, é desnecessário ter mais de um `launch.json` ou então ficar alterando as configurações do mesmo para obter configurações diferentes. Em outras palavras, significa que dentro do mesmo `launch.json` é possível ter uma configuração para inicializar a aplicação com configurações para ambiente de dev, ambiente de homologação, de produção e assim por diante.

Vejamos a seguir exemplo de configuração para inicializar a aplicação:

- Arquivo `launch.json`:

	    {
			"version":"0.2.0",
			"configurations":[
				{
					"name":"Test: Simple",
					"type":"go",
					"request":"launch",
					"mode":"debug",
					"program":"${workspaceFolder}/cmd",
					"env":{},
			        "args":[],
			        "showLog":true
			    },
		        {
					"name":"Test: Env And Args",
					"type":"go",
			        "request":"launch",
			        "mode":"debug",
			        "program":"${workspaceFolder}/cmd",
			        "envFile":"${workspaceFolder}/envfile.env",
			        "env":{
			            "HOST":"test.com"
			        },
			        "args":[
			            "redirect",
			            "test"
			        ],
			        "showLog":true
			    }
			]
		}

Repare que na configuração que corresponde a *Test: Env And Args* foi utilizado um arquivo que contém algumas variáveis de ambiente, **, tem o *env* no qual é possível também declarar variáveis de ambiente e o *args*, que é utilizado para passar argumentos a aplicação. Todos esses atributos possibilitam passar dados a aplicação.

- Arquivo `envfile.env`:

	    ENVIRONMENT=dev
	    MESSAGE=HELLO WORLD!
    
Desta forma, seria possível externalizar num arquivo *.env* as variáveis de ambiente que são comuns aos ambientes, ou seja, simplifica a configuração.

- Arquivo `main.go`:

		package main
		import (
			"fmt"
			"os"
		)

		func main() {
			HOST := os.Getenv("HOST")
			MESSAGE := os.Getenv("MESSAGE")
			ENVIRONMENT := os.Getenv("ENVIRONMENT")
			args := os.Args
			
			// without these println there is a compile error
			fmt.Println(fmt.Sprintf("Host: %s; Message: %s; Environment: %s", HOST, MESSAGE, ENVIRONMENT))

			for  i, arg := range args {
				fmt.Println(fmt.Sprintf("arg(%d): %s ", i, arg))
			}
			
		}

Ao executar o programa será possível visualizar todas as variáveis e seus respectivos valores no *painel de variáveis* do VSCode.

![painel_variaveis.png](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/vmbcj73dwqmwnwljen22.png)

## Inicializando a aplicação no modo debug

Para inicializar a aplicação é bem simples, só seguir os seguintes passos:

1. clicar no ícone *Run and Debug* que fica, por padrão, do lado esquerdo do VSCode;
2. selecionar qual configuração do *launch.json* se deseja executar;
3. adicionar breakpoint no ponto que deseja pausar a execução da aplicação;
4. clicar no botão *Start Debugging (F5)* - ou *Iniciar Depuração (F5)*.


![iniciar_aplicacao_debug.png](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/fnz9fvdwvzbgjqmb13l7.png)


## Conclusão

Com o passo-a-passo descrito eu espero que agora seja possível configurar o ambiente de desenvolvimento, fazendo uso das configurações no `launch.json` e, a debuggar a aplicação, para que se possa acompanhar o fluxo do sistema e suas variáveis, desta forma, melhorando a produtividade e o entendimento durante o desenvolvimento.

## Referências

- https://github.com/golang/vscode-go/blob/master/docs/debugging.md
- https://www.digitalocean.com/community/tutorials/debugging-go-code-with-visual-studio-code

## Apêndices

A seguir algumas informações sobre as tecnologias utilizadas para desenvolver esse exemplo de aplicação:

-  SO utilizado [Pop!_OS versão 22.04 LTS](https://pop.system76.com) 
-  Máquina Virtual (VM) foi utilizado o [Gnome Boxes](https://flathub.org/apps/details/org.gnome.Boxes) via flatpak;
-   Go na versão 1.19.4 instalado via [GVM](https://github.com/moovweb/gvm#installing);
-   [VSCode versão 1.74.1](https://flathub.org/apps/details/com.visualstudio.code) instalado via flatpak;