slides.slide

Error tracking

Diego Saouda

[[https://www.meetup.com/pt-BR/golangbr/events/262565039/]]


* MiniBio

Software Engineer na Finanças 360º ([[https://www.financas360.com.br]]) 

[[https://www.startupstowatch.com.br/#/list][_100_startup_to_watch_2019_]]


*Contatos*

[[https://github.com/dsaouda]]

[[https://www.linkedin.com/in/diegosaouda/]]




* Erros em Golang (try/catch???)

Só que não ... O tratamento de erros em go é diferente de linguagens como Java, C#, PHP, Javascript, etc ... Não existe try/catch!!!
 
Exemplo 1 de captura de erro

	_, err := os.Open("nao_existe")

	if err != nil {
		log.Fatalf("ocorreu um erro ao abrir arquivo (%v)", err)
	}
	// programa continua ...

Exemplo 2

	_, err := os.Open("nao_existe")

	if err != nil {
		fmt.Println(err)
		//fmt.Println(fmt.Sprintf("ocorreu um erro ao abrir arquivo (%v)", err))
		os.Exit(0)
	}

* Panic
		
É usado para falhar algo que não deveria ter ocorrido e evitar propagação de erros

	db := os.Getenv("DB_HOST")

	if strings.TrimSpace(db) == "" {
		panic("não é possível encontrar a variável de ambiente DB_HOST")
		// log.Panicf("não é possível encontrar a variável de ambiente DB_HOST: %v", err)
	}

	// implementacao de conexão com banco de dados

[[https://gobyexample.com/panic]]

* Defer

Usado para adiar a execução de uma função. Geralmente usado para liberar algum recurso

	db, err := sql.Open("mysql", "user:password@/dbname")
	if err != nil {
		log.Fatal("erro ao conectar: ", err.Error())
	}
	defer db.Close()

	insert, err := db.Query("INSERT INTO test VALUES ( 2, 'TEST' )")

	// continua ...

[[https://gobyexample.com/defer]]

* Recover

Uma função para recuperar o controle da chamada de um panic

	func main() {
		defer func() {
			if err := recover(); err != nil {
				fmt.Println(err)
				// enviar um e-mail com problema
				// gerar log
			}
		}()

		emitirNotaFiscal()
	}

	func emitirNotaFiscal() {
		// implementação da nota
		// emulando comunicação falha

		panic("nota fiscal não emitida: conexão falhou")
	}

[[https://yourbasic.org/golang/recover-from-panic/]]


* Lançando erros
	
	var (
		ErrorUsuarioNaoEncontrado = errors.New("Usuário não encontrado")
		ErrorEmailDuplicado = errors.New("Email duplicado")
	)
 
	var usuarios = []User{
		{1, "José Barbosa Sousa"},
		{2, "Samuel Sousa Souza"},
		{3, "Sophia Cardoso Cavalcanti"},
		{4, "Isabela Carvalho Ferreira"},
		{5, "Livia Dias Araujo"},
	}
 	
	func getUsuarioById(id int) (*User, error) {
		for _, user := range usuarios {
			if user.Id == id {
				return &user, nil
			}
		}
		return nil, ErrorUsuarioNaoEncontrado
	}


* Interface Error
	
Erros em go são criados implementando a interface abaixo:

	type error interface { 
		Error() string
	}

Exemplo de um novo tipo

	type InvalidArgumentError struct {
		Message string
		InnerError error
	}

	func (e *InvalidArgumentError) Error() string {
		erro := fmt.Sprint(" ** Exception -> ", e.Message)

		if e.InnerError != nil {
			erro = fmt.Sprint(erro, "\n\tInner: ", e.InnerError)
		}

		return erro
	}


* stack tracing
	
Por padrão "error" não fornece stack tracing. Para contornar essa limitação podemos usar a lib [[https://godoc.org/github.com/pkg/errors]].

	func main() {
		a, err := abrirArquivo("arquivo_nao_existe")
		if err != nil {
			fmt.Printf("%+v", err)
			os.Exit(0)
		}
		defer a.Close()
	}
 
	func abrirArquivo(filename string) (*os.File, error) {
		f, err := os.Open(filename)
		if err != nil {
			return nil, errors.Wrap(err, "O arquivo não foi localizado")
		}
		return f, nil
	}




* Error tracking

* Ferramentas

Abaixo algumas ferramentas que possuem suporte a ratreamento de erro em golang.

- airbrake [[https://airbrake.io/languages/golang-error-monitoring]]
- bugsnag [[https://docs.bugsnag.com/platforms/go/]]
- rollbar [[https://docs.rollbar.com/docs/go]]
- sentry [[https://sentry.io/for/go/]]

* Sentry 

- instalação lib Go

	go get github.com/getsentry/sentry-go
 
- configuração

	sentry.Init(sentry.ClientOptions{
		Dsn: "https://<key>@sentry.io/<project>",
	})

- Capturando eventos
	
	f, err := os.Open("filename.ext")
	if err != nil {
		sentry.CaptureException(err)
	}


* Sentry - Context

Capturando usuário

	sentry.ConfigureScope(func(scope *sentry.Scope) {
		scope.SetUser(sentry.User{Email: "john.doe@example.com"})
	})

Criando tags para evento

	sentry.ConfigureScope(func(scope *sentry.Scope) {
		scope.SetTag("page_locale", "de-at")
	})

Contexto Extra

	sentry.ConfigureScope(func(scope *sentry.Scope) {
		scope.SetExtra("character_name", "Mighty Fighter")
	})


* Sentry (Environments, Breadcrumb, Scopes)

Environments (Ambiente que gerou erro (dev, homolog, prod) - usado no filtro)

	sentry.Init(sentry.ClientOptions{
		Environment: "dev",
	})

Breadcrumbs (rastreamento de passos)

	sentry.AddBreadcrumb(&sentry.Breadcrumb{
		Category: "login",
		Message: "Logando",
		Level: sentry.LevelDebug,
	});

Scopes (enriquecer o erro com mais dados)
	
	sentry.WithScope(func(scope *sentry.Scope) {
		scope.SetUser(sentry.User{Email: "john.doe@example.com"})
		scope.SetTag("page_locale", "pt-br")
		scope.SetExtra("character_name", "Mighty Fighter")
		sentry.CaptureException(err)
	})

* Sentry (Release, Issue Owners, Integration)

Release (Usado para identificar em qual versão do deploy o erro foi gerado)

	sentry.Init(sentry.ClientOptions{
		Release: "my-project-name@2.3.12",
	})

Issue Owners (Padrão para atribuir um erro a um usuário)

	path:main.go john.doe@example.com

Integration

global: [[https://docs.sentry.io/workflow/integrations/#global-integrations]]
por projeto: [[https://docs.sentry.io/workflow/integrations/#per-project-integrations]]	

* Demos

* Instalando sentry local
	
- docker run -d --name sentry-redis redis
- docker run -d --name sentry-postgres -e POSTGRES_PASSWORD=secret -e POSTGRES_USER=sentry postgres
- docker run --rm sentry config generate-secret-key
- docker run -it --rm -e SENTRY_SECRET_KEY='<secret-key>' --link sentry-postgres:postgres --link sentry-redis:redis sentry upgrade
- docker run -d --name my-sentry -e SENTRY_SECRET_KEY='<secret-key>' --link sentry-redis:redis --link sentry-postgres:postgres sentry	
- docker run -d --name sentry-cron -e SENTRY_SECRET_KEY='<secret-key>' --link sentry-postgres:postgres --link sentry-redis:redis sentry run cron
- docker run -d --name sentry-worker-1 -e SENTRY_SECRET_KEY='<secret-key>' --link sentry-postgres:postgres --link sentry-redis:redis sentry run worker

* Links

- [[https://hub.docker.com/_/sentry/]]
- [[https://docs.sentry.io/error-reporting/quickstart/?platform=go]]
- [[https://github.com/getsentry/sentry-go]]
- [[https://gobyexample.com/]]
- [[https://github.com/golang/proposal/blob/master/design/go2draft-error-handling.md]]