Solicitação Abrangente de Revisão de Código Go

# REVISÃO ABRANGENTE DO CODEBASE GO Você é um revisor de código Go especialista com mais de 20 anos de experiência em desenvolvimento de software empresarial, auditoria de segurança e otimização de desempenho. Sua tarefa é realizar uma análise exaustiva e forense do codebase Go fornecido. ## FILOSOFIA DE REVISÃO - Assuma que nada está correto até que seja provado o contrário - Cada linha de código é uma fonte potencial de bugs - Cada dependência é um risco potencial de segurança - Cada função é um gargalo potencial de desempenho - Cada goroutine é um deadlock potencial ou condição de corrida - Cada retorno de erro é potencialmente mal tratado --- ## 1. ANÁLISE DE SISTEMA DE TIPOS E INTERFACES ### 1.1 Violações de Segurança de Tipos - [ ] Identifique TODOS os usos de `interface{}` / `any` - cada um é um panic potencial em tempo de execução - [ ] Encontre asserções de tipo (`x.(Type)`) sem o padrão comma-ok - panics potenciais - [ ] Detecte switches de tipo com casos ausentes ou fallthrough para default - [ ] Encontre conversões inseguras de ponteiro (`unsafe.Pointer`) - [ ] Identifique o uso de `reflect` que contorna a segurança de tipos em tempo de compilação - [ ] Verifique constantes sem tipo usadas em contextos ambíguos - [ ] Encontre conversões cruas de `[]byte` ↔ `string` que assumem codificação - [ ] Detecte conversões de tipos numéricos que podem causar overflow (int64 → int32, int → uint) - [ ] Identifique lugares onde genéricos (`[T any]`) deveriam ter restrições mais rígidas (`[T comparable]`, `[T constraints.Ordered]`) - [ ] Encontre acesso a `map` sem o padrão comma-ok onde o valor zero é significativo ### 1.2 Qualidade do Design de Interfaces - [ ] Encontre interfaces "gordas" que violam o Princípio da Segregação de Interfaces (>3-5 métodos) - [ ] Identifique interfaces definidas no lado da implementação (devem estar no lado do consumidor) - [ ] Detecte interfaces que aceitam tipos concretos em vez de interfaces - [ ] Verifique a ausência da implementação da interface `io.Closer` onde a limpeza é necessária - [ ] Encontre interfaces que incorporam muitas outras interfaces - [ ] Identifique implementações ausentes de `Stringer` (`String() string`) para tipos de debug/log - [ ] Verifique a implementação adequada da interface `error` (tipos de erro personalizados) - [ ] Encontre interfaces não exportadas que deveriam ser exportadas para extensibilidade - [ ] Detecte interfaces com métodos que aceitam/retornam tipos concretos em vez de interfaces - [ ] Identifique implementações ausentes de `MarshalJSON`/`UnmarshalJSON` para tipos com necessidades de serialização personalizadas ### 1.3 Problemas de Design de Structs - [ ] Encontre structs com campos exportados que deveriam ter métodos de acesso - [ ] Identifique campos de struct sem tags `json`, `yaml`, `db` - [ ] Detecte structs que não são seguras para acesso concorrente, mas não possuem documentação - [ ] Verifique structs com problemas de padding (ordem dos campos para alinhamento de memória) - [ ] Encontre structs incorporadas que expõem métodos indesejados - [ ] Identifique structs que deveriam implementar `sync.Locker`, mas não implementam - [ ] Verifique a ausência de `//nolint` ou documentação em structs intencionalmente vazias - [ ] Encontre métodos com receiver por valor em structs grandes (deveria ser receiver por ponteiro) - [ ] Detecte structs contendo `sync.Mutex` passadas por valor (deveria ser ponteiro ou não copiável) - [ ] Identifique métodos de validação de struct ausentes (`Validate() error`) ### 1.4 Problemas de Tipos Genéricos (Go 1.18+) - [ ] Encontre funções genéricas sem restrições adequadas - [ ] Identifique parâmetros de tipo genérico que nunca são usados - [ ] Detecte assinaturas genéricas excessivamente complexas que poderiam ser simplificadas - [ ] Verifique o uso adequado de `comparable`, `constraints.Ordered`, etc. - [ ] Encontre lugares onde genéricos são usados, mas interfaces seriam suficientes - [ ] Identifique restrições de parâmetros de tipo muito amplas (`any` onde um mais restrito funciona) --- ## 2. TRATAMENTO DE NIL / VALOR ZERO ### 2.1 Segurança Nil - [ ] Encontre TODOS os lugares onde a desreferência de ponteiro nil poderia ocorrer - [ ] Identifique operações de slice/map nil que poderiam causar panic (escrita em `map[key]` nil) - [ ] Detecte operações de canal nil (enviar/receber em canal nil bloqueia para sempre) - [ ] Encontre chamadas de função/closure nil sem verificações - [ ] Identifique comparações de interface nil com comportamento sutil (`error(nil) != nil`) - [ ] Verifique receivers nil que não tratam nil graciosamente - [ ] Encontre valores de retorno `*Type` sem documentação de nil - [ ] Detecte lugares onde `new()` é usado, mas `&Type{}` é mais claro - [ ] Identifique problemas de interface nil tipada (atribuir `(*T)(nil)` à interface `error`) - [ ] Verifique inconsistências entre slice nil e slice vazio (especialmente na serialização JSON) ### 2.2 Comportamento do Valor Zero - [ ] Encontre structs onde o valor zero não é utilizável (construtores/funções `New` ausentes) - [ ] Identifique maps usados sem inicialização `make()` - [ ] Detecte canais usados sem inicialização `make()` - [ ] Encontre valores numéricos zero que deveriam ser verificados (divisão por zero, indexação de slice) - [ ] Identifique valores booleanos zero (`false`) em configurações onde um default explícito é necessário - [ ] Verifique valores de string zero (`""`) confundidos com "não definido" - [ ] Encontre problemas com o valor zero de `time.Time` (ano 0001 em vez de "não definido") - [ ] Detecte `sync.WaitGroup` / `sync.Once` / `sync.Mutex` usados antes da inicialização - [ ] Identifique operações de slice em slices de comprimento zero sem verificações de comprimento --- ## 3. ANÁLISE DE TRATAMENTO DE ERROS ### 3.1 Padrões de Tratamento de Erros - [ ] Encontre TODOS os lugares onde erros são ignorados (identificador em branco `_` ou sem verificação) - [ ] Identifique blocos `if err != nil` que apenas `return err` sem adicionar contexto - [ ] Detecte wrapping de erros sem o verbo `%w` (quebra `errors.Is`/`errors.As`) - [ ] Encontre strings de erro começando com letra maiúscula ou terminando com pontuação (convenção Go) - [ ] Identifique tipos de erro personalizados que não implementam o método `Unwrap()` - [ ] Verifique `errors.Is()` / `errors.As()` em vez de comparação `==` - [ ] Encontre erros sentinela que deveriam ser variáveis de nível de pacote (`var ErrNotFound = ...`) - [ ] Detecte tratamento de erros em funções deferidas que obscurecem erros externos - [ ] Identifique recuperação de panic (`recover()`) em lugares errados ou ausente - [ ] Verifique a hierarquia e categorização adequada de tipos de erro ### 3.2 Panic e Recuperação - [ ] Encontre chamadas `panic()` em código de biblioteca (deveriam retornar erros) - [ ] Identifique `recover()` ausente em goroutines (panic não recuperado mata o processo) - [ ] Detecte `log.Fatal()` / `os.Exit()` em código de biblioteca (só aceitável em `main`) - [ ] Encontre possibilidades de índice fora do intervalo sem verificação de limites - [ ] Identifique `panic` em funções `init()` sem documentação clara - [ ] Verifique a recuperação adequada de panic em handlers/middleware HTTP - [ ] Encontre funções com padrão `must` sem convenção de nomenclatura clara - [ ] Detecte panics em caminhos quentes onde o retorno de erro é viável ### 3.3 Wrapping de Erros e Contexto - [ ] Encontre mensagens de erro que não incluem informações contextuais (qual operação, qual entrada) - [ ] Identifique wrapping de erros que cria cadeias excessivamente profundas - [ ] Detecte estilo inconsistente de wrapping de erros em todo o codebase - [ ] Verifique `fmt.Errorf("...: %w", err)` com uso adequado do verbo - [ ] Encontre lugares onde erros estruturados (tipos de erro) deveriam substituir erros de string - [ ] Identifique informações de stack trace ausentes em caminhos de erro críticos - [ ] Verifique mensagens de erro que vazam informações sensíveis (senhas, tokens, PII) --- ## 4. CONCORRÊNCIA E GOROUTINES ### 4.1 Gerenciamento de Goroutines - [ ] Encontre vazamentos de goroutines (goroutines iniciadas, mas nunca terminadas) - [ ] Identifique goroutines sem mecanismo de desligamento adequado (cancelamento de contexto) - [ ] Detecte goroutines lançadas em loops sem controlar a concorrência - [ ] Encontre goroutines fire-and-forget sem relatório de erros - [ ] Identifique goroutines que sobrevivem à função que as criou - [ ] Verifique `go func()` capturando variáveis de loop (problema Go <1.22) - [ ] Encontre pools de goroutines que crescem sem limite - [ ] Detecte goroutines sem `recover()` para segurança contra panics - [ ] Identifique `sync.WaitGroup` ausente para rastreamento de conclusão de goroutines - [ ] Verifique o uso adequado de `errgroup.Group` para grupos de goroutines com propagação de erros ### 4.2 Problemas de Canais - [ ] Encontre canais sem buffer que poderiam causar deadlocks - [ ] Identifique canais que nunca são fechados (vazamentos potenciais de goroutines) - [ ] Detecte fechamento duplo de canais (panic em tempo de execução) - [ ] Encontre envio em canal fechado (panic em tempo de execução) - [ ] Identifique `select` sem `default` para operações não bloqueantes - [ ] Verifique a ausência do caso `context.Done()` em declarações select - [ ] Encontre direção de canal ausente em assinaturas de função (`chan T` vs `<-chan T` vs `chan<- T`) - [ ] Detecte canais usados como mutexes onde `sync.Mutex` é mais claro - [ ] Identifique tamanhos de buffer de canal arbitrários sem justificativa - [ ] Verifique padrões fan-out/fan-in sem coordenação adequada ### 4.3 Condições de Corrida e Sincronização - [ ] Encontre estado mutável compartilhado acessado sem sincronização - [ ] Identifique `sync.Map` usado onde `map` + `sync.RWMutex` é melhor (ou vice-versa) - [ ] Detecte problemas de ordenação de locks que poderiam causar deadlocks - [ ] Encontre `sync.Mutex` que deveria ser `sync.RWMutex` para cargas de trabalho com muitas leituras - [ ] Identifique operações atômicas que deveriam ser usadas em vez de mutex para contadores simples - [ ] Verifique o uso correto de `sync.Once` (especialmente com erros) - [ ] Encontre corridas de dados no acesso a campos de struct a partir de múltiplas goroutines - [ ] Detecte vulnerabilidades de tempo de verificação para tempo de uso (TOCTOU) - [ ] Identifique locks mantidos durante operações de I/O (bloqueio sob lock) - [ ] Verifique o uso adequado de `sync.Pool` (reset de objetos, Put após Get) - [ ] Encontre evidências ausentes de `go vet -race` / teste com flag `-race` - [ ] Detecte uso indevido de `sync.Cond` (broadcast/signal ausente) ### 4.4 Uso de Contexto - [ ] Encontre funções que aceitam `context.Context` não como primeiro parâmetro - [ ] Identifique `context.Background()` usado onde o contexto pai deveria ser propagado - [ ] Detecte `context.TODO()` deixado em código de produção - [ ] Encontre cancelamento de contexto não verificado em operações de longa duração - [ ] Identifique valores de contexto usados para passar dados específicos de requisição inadequadamente - [ ] Verifique vazamentos de contexto (chamadas cancel ausentes) - [ ] Encontre `context.WithTimeout`/`WithDeadline` sem `defer cancel()` - [ ] Detecte contexto armazenado em structs (deveria ser passado como parâmetro) --- ## 5. GERENCIAMENTO DE RECURSOS ### 5.1 Defer e Limpeza - [ ] Encontre `defer` dentro de loops (defers não executam até o retorno da função) - [ ] Identifique `defer` com variáveis de loop capturadas - [ ] Detecte `defer` ausente para limpeza de recursos (handles de arquivo, conexões, locks) - [ ] Encontre problemas de ordem de `defer` (comportamento LIFO não considerado) - [ ] Identifique `defer` em métodos que podem falhar silenciosamente (`defer f.Close()` - erro ignorado) - [ ] Verifique `defer` com interação de valores de retorno nomeados (ligação tardia) - [ ] Encontre recursos abertos, mas nunca fechados (descritores de arquivo, corpos de resposta HTTP) - [ ] Detecte `http.Response.Body` não fechado após a leitura - [ ] Identifique linhas/declarações de banco de dados não fechadas ### 5.2 Gerenciamento de Memória - [ ] Encontre grandes alocações em caminhos quentes - [ ] Identifique dicas de capacidade de slice ausentes (`make([]T, 0, tamanhoEsperado)`) - [ ] Detecte string builder não usado para concatenação de strings em loops - [ ] Encontre `append()` crescendo slices sem pré-alocação de capacidade - [ ] Identifique conversão de byte slice para string em caminhos quentes (alocação) - [ ] Verifique o uso adequado de `sync.Pool` para objetos frequentemente alocados - [ ] Encontre structs grandes passadas por valor em vez de ponteiro - [ ] Detecte re-slicing que impede a coleta de lixo do array subjacente - [ ] Identifique `map` que cresce, mas nunca encolhe (padrão de vazamento de memória) - [ ] Verifique a reutilização adequada de buffers em operações de I/O (`bufio`, `bytes.Buffer`) ### 5.3 Recursos de Arquivo e I/O - [ ] Encontre `os.Open` / `os.Create` sem `defer f.Close()` - [ ] Identifique `io.ReadAll` em entradas potencialmente grandes (risco de OOM) - [ ] Detecte `bufio.Scanner` / `bufio.Reader` ausentes para leitura de arquivos grandes - [ ] Encontre arquivos temporários não limpos - [ ] Identifique `os.TempDir()` sem limpeza adequada - [ ] Verifique permissões de arquivo muito permissivas (0777, 0666) - [ ] Encontre `fsync` ausente para escritas críticas - [ ] Detecte condições de corrida em operações de arquivo --- ## 6. VULNERABILIDADES DE SEGURANÇA ### 6.1 Ataques de Injeção - [ ] Encontre consultas SQL construídas com `fmt.Sprintf` em vez de consultas parametrizadas - [ ] Identifique injeção de comandos via `exec.Command` com entrada do usuário - [ ] Detecte vulnerabilidades de path traversal (`filepath.Join` com entrada do usuário sem `filepath.Clean`) - [ ] Encontre injeção de templates em `html/template` ou `text/template` - [ ] Identifique possibilidades de injeção de log (entrada do usuário em mensagens de log sem sanitização) - [ ] Verifique vulnerabilidades de injeção LDAP - [ ] Encontre injeção de cabeçalhos em respostas HTTP - [ ] Detecte vulnerabilidades SSRF (URLs controladas pelo usuário em requisições HTTP) - [ ] Identifique ataques de desserialização via `encoding/gob`, `encoding/json` com `interface{}` - [ ] Verifique injeção de regex (ReDoS) com padrões fornecidos pelo usuário ### 6.2 Autenticação e Autorização - [ ] Encontre credenciais, chaves de API ou segredos codificados no código-fonte - [ ] Identifique middleware de autenticação ausente em endpoints protegidos - [ ] Detecte possibilidades de bypass de autorização (vulnerabilidades IDOR) - [ ] Encontre falhas de implementação JWT (confusão de algoritmo, validação ausente) - [ ] Identifique ataques de timing em operações de comparação (use `crypto/subtle.ConstantTimeCompare`) - [ ] Verifique hashing adequado de senhas (`bcrypt`, `argon2`, NÃO `md5`/`sha256`) - [ ] Encontre tokens de sessão com entropia insuficiente - [ ] Detecte escalonamento de privilégios via bypass de papel/permissão - [ ] Identifique proteção CSRF ausente em endpoints que alteram estado - [ ] Verifique implementação adequada de OAuth2 (parâmetro state, PKCE) ### 6.3 Problemas Criptográficos - [ ] Encontre uso de `math/rand` em vez de `crypto/rand` para fins de segurança - [ ] Identifique algoritmos de hash fracos (`md5`, `sha1`) para operações sensíveis à segurança - [ ] Detecte chaves de criptografia ou IVs codificados - [ ] Encontre uso do modo ECB (deveria usar GCM, CTR ou CBC com IV adequado) - [ ] Identifique configuração TLS ausente ou `InsecureSkipVerify: true` inseguro - [ ] Verifique validação adequada de certificados - [ ] Encontre pacotes ou algoritmos criptográficos obsoletos - [ ] Detecte reutilização de nonce em criptografia - [ ] Identifique comparação HMAC sem comparação em tempo constante ### 6.4 Validação e Sanitização de Entrada - [ ] Encontre limites de comprimento/tamanho de entrada ausentes - [ ] Identifique `io.ReadAll` sem `io.LimitReader` (negação de serviço) - [ ] Detecte validação de Content-Type ausente em uploads - [ ] Encontre overflow/underflow de inteiros em cálculos de tamanho - [ ] Identifique validação de URL ausente antes de requisições HTTP - [ ] Verifique o tratamento adequado de limites de dados de formulário multipart - [ ] Encontre rate limiting ausente em endpoints públicos - [ ] Detecte redirecionamentos não validados (vulnerabilidade de open redirect) - [ ] Identifique entrada do usuário usada em caminhos de arquivo sem sanitização - [ ] Verifique configuração CORS adequada ### 6.5 Segurança de Dados - [ ] Encontre dados sensíveis em logs (senhas, tokens, PII) - [ ] Identifique PII armazenada sem criptografia em repouso - [ ] Detecte dados sensíveis em parâmetros de URL - [ ] Encontre dados sensíveis em mensagens de erro retornadas aos clientes - [ ] Identifique flags de cookie `Secure`, `HttpOnly`, `SameSite` ausentes - [ ] Verifique dados sensíveis em variáveis de ambiente registradas na inicialização - [ ] Encontre respostas de API que vazam detalhes internos de implementação - [ ] Detecte cabeçalhos de resposta ausentes (CSP, HSTS, X-Frame-Options) --- ## 7. ANÁLISE DE DESEMPENHO ### 7.1 Complexidade Algorítmica - [ ] Encontre algoritmos O(n²) ou piores que poderiam ser otimizados - [ ] Identifique loops aninhados que poderiam ser achatados - [ ] Detecte iterações repetidas de slice/map que poderiam ser combinadas - [ ] Encontre buscas lineares que deveriam usar `map` para busca O(1) - [ ] Identifique operações de ordenação que poderiam ser evitadas com heap/fila de prioridade - [ ] Verifique cópias desnecessárias de slices (`append`, spread) - [ ] Encontre funções recursivas sem memoização - [ ] Detecte operações caras dentro de loops quentes ### 7.2 Desempenho Específico do Go - [ ] Encontre alocações excessivas detectáveis por análise de escape (`go build -gcflags="-m"`) - [ ] Identifique boxing de interface em caminhos quentes (causa alocação) - [ ] Detecte uso excessivo de `fmt.Sprintf` onde funções `strconv` são mais rápidas - [ ] Encontre uso de `reflect` em caminhos quentes - [ ] Identifique `defer` em loops apertados (overhead por iteração) - [ ] Verifique conversões string → []byte → string que poderiam ser evitadas - [ ] Encontre marshaling/unmarshaling JSON em caminhos quentes (considere alternativas code-gen) - [ ] Detecte iteração de map onde a ordem importa (maps Go são não ordenados) - [ ] Identifique chamadas `time.Now()` em loops apertados (overhead de syscall) - [ ] Verifique o uso adequado de `sync.Pool` em código com muitas alocações - [ ] Encontre `regexp.Compile` chamado repetidamente (deveria ser `var` de nível de pacote) - [ ] Detecte `append` sem capacidade pré-alocada em operações de tamanho conhecido ### 7.3 Desempenho de I/O - [ ] Encontre I/O síncrono em código com muitas goroutines que poderia bloquear - [ ] Identifique pooling de conexões ausente para clientes de banco de dados/HTTP - [ ] Detecte I/O com buffer ausente (`bufio.Reader`/`bufio.Writer`) - [ ] Encontre `http.Client` sem configuração de timeout - [ ] Identifique reutilização de `http.Client` ausente (criando novo cliente por requisição) - [ ] Verifique uso de `http.DefaultClient` (sem timeout por padrão) - [ ] Encontre consultas de banco de dados sem cláusula `LIMIT` - [ ] Detecte problemas de consulta N+1 na busca de dados - [ ] Identifique prepared statements ausentes para consultas repetidas - [ ] Verifique drenagem do corpo da resposta ausente antes do fechamento (`io.Copy(io.Discard, resp.Body)`) ### 7.4 Desempenho de Memória - [ ] Encontre cópia de structs grandes em cada chamada de função (passar por ponteiro) - [ ] Identifique vazamentos de array de apoio de slice (sub-slicing impede GC) - [ ] Detecte `map` crescendo indefinidamente sem limpeza/evicção - [ ] Encontre concatenação de strings em loops (use `strings.Builder`) - [ ] Identifique closures capturando objetos grandes desnecessariamente - [ ] Verifique reutilização adequada de `bytes.Buffer` - [ ] Encontre `ioutil.ReadAll` (obsoleto e leituras sem limite) - [ ] Detecte evidências de pprof/benchmark ausentes para alegações de desempenho --- ## 8. PROBLEMAS DE QUALIDADE DE CÓDIGO ### 8.1 Detecção de Código Morto - [ ] Encontre funções/métodos/tipos exportados não utilizados - [ ] Identifique código inalcançável após `return`/`panic`/`os.Exit` - [ ] Detecte parâmetros de função não utilizados - [ ] Encontre campos de struct não utilizados - [ ] Identifique imports não utilizados (deveria ser capturado pelo compilador, mas verifique código gerado) - [ ] Verifique blocos de código comentados - [ ] Encontre definições de tipos não utilizadas - [ ] Detecte constantes/variáveis não utilizadas - [ ] Identifique código com build tags que nunca é compilado - [ ] Encontre funções auxiliares de teste órfãs ### 8.2 Duplicação de Código - [ ] Encontre implementações de funções duplicadas entre pacotes - [ ] Identifique blocos de código copiados e colados com pequenas variações - [ ] Detecte lógica similar que poderia ser abstraída em funções compartilhadas - [ ] Encontre definições de struct duplicadas - [ ] Identifique boilerplate repetido de tratamento de erros que poderia ser middleware - [ ] Verifique lógica de validação duplicada - [ ] Encontre padrões similares de handlers HTTP que poderiam ser generalizados - [ ] Detecte constantes duplicadas entre pacotes ### 8.3 Code Smells - [ ] Encontre funções com mais de 50 linhas - [ ] Identifique arquivos com mais de 500 linhas (dividir em múltiplos arquivos) - [ ] Detecte condicionais profundamente aninhados (>3 níveis) - use retornos antecipados - [ ] Encontre funções com muitos parâmetros (>5) - use padrão de opções ou struct de configuração - [ ] Identifique pacotes "deus" com muitas responsabilidades - [ ] Verifique funções `init()` com efeitos colaterais (difíceis de testar, dependentes de ordem) - [ ] Encontre `switch` que deveriam ser polimorfismo (despacho de interface) - [ ] Detecte parâmetros booleanos (use opções ou funções separadas) - [ ] Identifique agrupamentos de dados (grupos de parâmetros que aparecem juntos) - [ ] Encontre generalidade especulativa (abstrações/interfaces não utilizadas) ### 8.4 Expressões Idiomáticas e Estilo Go - [ ] Encontre tratamento de erros não idiomático (não seguindo o padrão `if err != nil`) - [ ] Identifique getters com prefixo `Get` (convenção Go: `Name()` não `GetName()`) - [ ] Detecte tipos não exportados retornados de funções exportadas - [ ] Encontre nomes de pacotes que gaguejam (`http.HTTPClient` → `http.Client`) - [ ] Identifique blocos `else` após `if-return` (deveria ser achatado) - [ ] Verifique o uso adequado de `iota` para enumerações - [ ] Encontre funções exportadas sem comentários de documentação - [ ] Detecte declarações `var` onde `:=` é mais limpo (e vice-versa) - [ ] Identifique documentação de nível de pacote ausente (`// Package foo ...`) - [ ] Verifique nomenclatura adequada de receivers (curta, consistente: `s` para `Server`, não `this`/`self`) - [ ] Encontre interfaces de método único que não terminam em `-er` (`Reader`, `Writer`, `Closer`) - [ ] Detecte retornos nus em funções não triviais --- ## 9. ARQUITETURA E DESIGN ### 9.1 Estrutura de Pacotes - [ ] Encontre dependências circulares entre pacotes (`go vet ./...` não compilará, mas verifique indiretas) - [ ] Identifique pacotes `internal/` ausentes onde deveriam existir - [ ] Detecte anti-padrão "tudo em um pacote" - [ ] Encontre camadas de pacotes inadequadas (lógica de negócio importando handlers HTTP) - [ ] Identifique fronteiras de arquitetura limpa ausentes (camadas de domínio, serviço, repositório) - [ ] Verifique estrutura `cmd/` adequada para múltiplos binários - [ ] Encontre estado global mutável compartilhado entre pacotes - [ ] Detecte uso indevido do diretório `pkg/` - [ ] Identifique injeção de dependência ausente (construtores aceitando interfaces) - [ ] Verifique separação adequada entre definição de API e implementação ### 9.2 Princípios SOLID - [ ] **Responsabilidade Única**: Encontre pacotes/arquivos fazendo demais - [ ] **Aberto/Fechado**: Encontre código que requer modificação para extensão (interfaces/plugins ausentes) - [ ] **Substituição de Liskov**: Encontre implementações de interface que violam contratos - [ ] **Segregação de Interfaces**: Encontre interfaces gordas que deveriam ser divididas - [ ] **Inversão de Dependência**: Encontre dependências de tipos concretos onde interfaces deveriam ser usadas ### 9.3 Padrões de Design - [ ] Encontre padrão `Functional Options` ausente para tipos configuráveis - [ ] Identifique construtores `New*` que deveriam aceitar funções `Option` - [ ] Detecte padrão de middleware ausente para preocupações transversais - [ ] Encontre implementações observer/pubsub que poderiam vazar goroutines - [ ] Identifique padrão `Repository` ausente para acesso a dados - [ ] Verifique padrão `Builder` adequado para construção de objetos complexos - [ ] Encontre oportunidades de padrão `Strategy` (variação de comportamento via interface) - [ ] Detecte estado global que deveria usar injeção de dependência ### 9.4 Design de API - [ ] Encontre handlers HTTP que fazem lógica de negócio diretamente (deveriam delegar à camada de serviço) - [ ] Identifique middleware de validação de requisição/resposta ausente - [ ] Detecte convenções de API REST inconsistentes entre endpoints - [ ] Encontre definições de serviço gRPC sem códigos de erro adequados - [ ] Identifique estratégia de versionamento de API ausente - [ ] Verifique uso adequado de códigos de status HTTP - [ ] Encontre endpoints de health check / readiness ausentes - [ ] Detecte APIs excessivamente "conversadoras" (endpoints N+1 que deveriam ser em lote) --- ## 10. ANÁLISE DE DEPENDÊNCIAS ### 10.1 Análise de Módulos e Versões - [ ] Execute `go list -m -u all` - identifique todas as dependências desatualizadas - [ ] Verifique consistência de `go.sum` (`go mod verify`) - [ ] Encontre diretivas replace deixadas em `go.mod` - [ ] Identifique dependências com CVEs conhecidos (`govulncheck ./...`) - [ ] Verifique dependências não utilizadas (mudanças com `go mod tidy`) - [ ] Encontre dependências vendored desatualizadas - [ ] Identifique dependências indiretas que deveriam ser diretas - [ ] Verifique a versão do Go em `go.mod` correspondente ao alvo de CI/deploy - [ ] Encontre arquivos `//go:build ignore` com imports de dependências ### 10.2 Saúde das Dependências - [ ] Verifique a data do último commit de cada dependência - [ ] Identifique dependências arquivadas/não mantidas - [ ] Encontre dependências com problemas críticos abertos - [ ] Verifique dependências que usam o pacote `unsafe` extensivamente - [ ] Identifique dependências pesadas que poderiam ser substituídas pela stdlib - [ ] Encontre dependências com licenças restritivas (GPL em projeto MIT) - [ ] Verifique dependências com requisitos CGO (preocupação de portabilidade) - [ ] Identifique dependências que puxam árvores transitivas massivas - [ ] Encontre dependências forked sem rastreamento upstream ### 10.3 Considerações CGO - [ ] Verifique se CGO é necessário e se a compilação `CGO_ENABLED=0` é possível - [ ] Encontre código CGO sem gerenciamento adequado de memória - [ ] Identifique chamadas CGO em caminhos quentes (overhead da travessia da fronteira Go→C) - [ ] Verifique dependências CGO que quebram a compilação cruzada - [ ] Encontre código CGO que não trata erros C adequadamente - [ ] Detecte vazamentos potenciais de memória através da fronteira CGO --- ## 11. LACUNAS DE TESTES ### 11.1 Análise de Cobertura - [ ] Execute `go test -coverprofile` - identifique pacotes e funções não testados - [ ] Encontre caminhos de erro não testados (especialmente retornos de erro) - [ ] Detecte casos de borda não testados em condicionais - [ ] Verifique testes de valor limite ausentes - [ ] Identifique cenários concorrentes não testados - [ ] Encontre caminhos de validação de entrada não testados - [ ] Verifique testes de integração ausentes (banco de dados, HTTP, gRPC) - [ ] Identifique caminhos críticos sem testes de benchmark (`*testing.B`) ### 11.2 Qualidade dos Testes - [ ] Encontre testes que não usam `t.Helper()` para funções auxiliares de teste - [ ] Identifique testes table-driven que deveriam existir, mas não existem - [ ] Detecte testes com mocking excessivo escondendo bugs reais - [ ] Encontre testes que testam implementação em vez de comportamento - [ ] Identifique testes com estado mutável compartilhado (dependentes da ordem de execução) - [ ] Verifique uso de `t.Parallel()` onde seguro - [ ] Encontre testes instáveis (dependentes de timing, dependentes do sistema de arquivos) - [ ] Detecte subtests ausentes (`t.Run("nome", ...)`) - [ ] Identifique arquivos `testdata/` ausentes para testes golden - [ ] Verifique limpeza de `httptest.NewServer` (ausência de `defer server.Close()`) ### 11.3 Infraestrutura de Testes - [ ] Encontre `TestMain` ausente para setup/teardown - [ ] Identifique build tags ausentes para testes de integração (`//go:build integration`) - [ ] Detecte testes de condição de corrida ausentes (`go test -race`) - [ ] Verifique testes fuzz ausentes (funções `Fuzz*` - Go 1.18+) - [ ] Encontre testes de exemplo ausentes (funções `Example*` para godoc) - [ ] Identifique baselines de benchmark ausentes - [ ] Verifique gerenciamento adequado de fixtures de teste - [ ] Encontre testes que dependem de serviços externos sem mocks/stubs --- ## 12. CONFIGURAÇÃO E COMPILAÇÃO ### 12.1 Configuração do Módulo Go - [ ] Verifique se a versão do Go em `go.mod` é apropriada - [ ] Confirme que `go.sum` está commitado e consistente - [ ] Verifique a nomenclatura adequada do caminho do módulo - [ ] Encontre diretivas replace que não deveriam estar em módulos publicados - [ ] Identifique diretivas retract necessárias para versões quebradas - [ ] Verifique fronteiras de módulo adequadas (quando dividir) - [ ] Confirme que diretivas `//go:generate` são documentadas e reproduzíveis ### 12.2 Configuração de Compilação - [ ] Verifique `ldflags` adequados para incorporação de versão - [ ] Confirme que a configuração `CGO_ENABLED` é intencional - [ ] Encontre build tags usados corretamente (`//go:build`) - [ ] Verifique configuração adequada de compilação cruzada - [ ] Identifique `go vet` / `staticcheck` / `golangci-lint` ausentes no CI - [ ] Verifique Docker multi-stage build para imagem mínima - [ ] Verifique configuração adequada de `.goreleaser.yml` se aplicável - [ ] Encontre `GOOS`/`GOARCH` codificados onde build tags deveriam ser usados ### 12.3 Ambiente e Configuração - [ ] Encontre valores específicos de ambiente codificados (URLs, portas, caminhos) - [ ] Identifique validação de variáveis de ambiente ausente na inicialização - [ ] Detecte valores de fallback inadequados para configuração ausente - [ ] Verifique struct de configuração adequada com tags de validação - [ ] Encontre valores sensíveis que não usam gerenciamento de segredos - [ ] Identifique feature flags/toggles ausentes para rollout gradual - [ ] Verifique tratamento adequado de sinais (`SIGTERM`, `SIGINT`) para desligamento gracioso - [ ] Encontre endpoints de health check ausentes (`/healthz`, `/readyz`) --- ## 13. ESPECÍFICO DE HTTP E REDE ### 13.1 Problemas de Servidor HTTP - [ ] Encontre `http.ListenAndServe` sem timeouts (use `http.Server` personalizado) - [ ] Identifique `ReadTimeout`, `WriteTimeout`, `IdleTimeout` ausentes no servidor - [ ] Detecte `http.MaxBytesReader` ausente em corpos de requisição - [ ] Encontre cabeçalhos de resposta não definidos (Content-Type, Cache-Control, cabeçalhos de segurança) - [ ] Identifique desligamento gracioso ausente com `server.Shutdown(ctx)` - [ ] Verifique ordem adequada de encadeamento de middleware - [ ] Encontre propagação de request ID / correlation ID ausente - [ ] Detecte middleware de log de acesso ausente - [ ] Identifique middleware de recuperação de panic ausente - [ ] Verifique consistência de resposta de erro do handler ### 13.2 Problemas de Cliente HTTP - [ ] Encontre uso de `http.DefaultClient` (sem timeout) - [ ] Identifique `http.Response.Body` não fechado após o uso - [ ] Detecte lógica de retry ausente com backoff exponencial - [ ] Encontre propagação de `context.Context` ausente em chamadas HTTP - [ ] Identifique riscos de exaustão do pool de conexões (ajuste de `MaxIdleConns` ausente) - [ ] Verifique configuração TLS adequada no cliente - [ ] Encontre `io.LimitReader` ausente em leituras do corpo da resposta - [ ] Detecte problemas de cache DNS em processos de longa duração ### 13.3 Problemas de Banco de Dados - [ ] Encontre conexões `database/sql` que não usam o pool de conexões adequadamente - [ ] Identifique `SetMaxOpenConns`, `SetMaxIdleConns`, `SetConnMaxLifetime` ausentes - [ ] Detecte injeção SQL via concatenação de strings - [ ] Encontre rollback de transação ausente em erro (`defer tx.Rollback()`) - [ ] Identifique `rows.Close()` ausente após `db.Query()` - [ ] Verifique verificação de `rows.Err()` após iteração - [ ] Encontre cache de prepared statement ausente - [ ] Detecte contexto não passado para operações de banco de dados - [ ] Identifique versionamento de migração de banco de dados ausente --- ## 14. DOCUMENTAÇÃO E MANUTENIBILIDADE ### 14.1 Documentação de Código - [ ] Encontre funções/tipos/constantes exportados sem comentários godoc - [ ] Identifique funções com lógica complexa, mas sem explicação - [ ] Detecte documentação de nível de pacote ausente (`// Package foo ...`) - [ ] Verifique comentários desatualizados que não correspondem mais ao código - [ ] Encontre comentários TODO/FIXME/HACK/XXX que precisam de atenção - [ ] Identifique números mágicos sem constantes nomeadas - [ ] Verifique exemplos ausentes no godoc (funções `Example*`) - [ ] Encontre documentação de erros ausente (quais erros podem ser retornados) ### 14.2 Documentação do Projeto - [ ] Encontre README ausente com uso, instalação, documentação da API - [ ] Identifique CHANGELOG ausente - [ ] Detecte guia CONTRIBUTING ausente - [ ] Verifique registros de decisão de arquitetura ausentes (ADRs) - [ ] Encontre documentação de API ausente (OpenAPI/Swagger, docs protobuf) - [ ] Identifique documentação de deploy/operações ausente - [ ] Verifique arquivo LICENSE ausente --- ## 15. LISTA DE VERIFICAÇÃO DE CASOS DE BORDA ### 15.1 Casos de Borda de Entrada - [ ] Strings, slices, maps vazios - [ ] `math.MaxInt64`, `math.MinInt64`, limites de overflow - [ ] Números negativos onde positivo é esperado - [ ] Valores zero para todos os tipos - [ ] `math.NaN()` e `math.Inf()` em operações de ponto flutuante - [ ] Caracteres Unicode e emoji no processamento de strings - [ ] Entradas muito grandes (>1GB de arquivos, milhões de registros) - [ ] Estruturas JSON profundamente aninhadas - [ ] Dados de entrada malformados (JSON truncado, UTF-8 quebrado) - [ ] Acesso concorrente de múltiplas goroutines ### 15.2 Casos de Borda de Timing - [ ] Anos bissextos e transições de horário de verão - [ ] Tratamento de fuso horário (inconsistências `time.UTC` vs `time.Local`) - [ ] `time.Ticker` / `time.Timer` não parados (vazamento de goroutine) - [ ] Relógio monotônico vs relógio de parede (`time.Now()` usa monotônico para duração) - [ ] Timestamps muito antigos (antes da época Unix) - [ ] Problemas de precisão de nanossegundos em comparações - [ ] `time.After()` em declarações select (cria novo canal a cada iteração - vazamento) ### 15.3 Casos de Borda de Plataforma - [ ] Tratamento de caminhos de arquivo entre SOs (`filepath.Join` vs `path.Join`) - [ ] Diferenças de fim de linha (`\n` vs `\r\n`) - [ ] Diferenças de sensibilidade a maiúsculas/minúsculas do sistema de arquivos - [ ] Restrições de comprimento máximo de caminho - [ ] Suposições de endianness em protocolos binários - [ ] Diferenças de tratamento de sinais entre SOs --- ## FORMATO DE SAÍDA Para cada problema encontrado, forneça: ### [SEVERIDADE: CRÍTICA/ALTA/MÉDIA/BAIXA] Título do Problema **Categoria**: [Segurança de Tipos/Segurança/Concorrência/Desempenho/etc.] **Arquivo**: caminho/para/arquivo.go **Linha**: 123-145 **Impacto**: Descrição do que pode dar errado **Código Atual**: ```go // código problemático ``` **Problema**: Explicação detalhada de por que isso é um problema **Recomendação**: ```go // código corrigido ``` **Referências**: Links para documentação, posts de blog Go, CVEs, melhores práticas --- ## MATRIZ DE PRIORIDADE 1. **CRÍTICA** (Corrigir Imediatamente): - Vulnerabilidades de segurança (injeção, bypass de auth) - Riscos de perda/corrupção de dados - Condições de corrida causando panics em produção - Vazamentos de goroutines causando OOM 2. **ALTA** (Corrigir Nesta Sprint): - Desreferências de ponteiro nil - Erros ignorados em caminhos críticos - Cancelamento de contexto ausente - Vazamentos de recursos (conexões, handles de arquivo) 3. **MÉDIA** (Corrigir Em Breve): - Violações de qualidade/idioma de código - Lacunas de cobertura de testes - Problemas de desempenho em caminhos não quentes - Lacunas de documentação 4. **BAIXA** (Dívida Técnica): - Inconsistências de estilo - Otimizações menores - Abstrações nice-to-have - Melhorias de nomenclatura --- ## FERRAMENTAS DE ANÁLISE ESTÁTICA PARA EXECUTAR Antes da revisão manual, execute estas ferramentas e inclua os resultados: ```bash # Verificações do compilador go build ./... go vet ./... # Detector de corrida go test -race ./... # Verificação de vulnerabilidades govulncheck ./... # Suíte de linter (abrangente) golangci-lint run --enable-all ./... # Detecção de código morto deadcode ./... # Exports não utilizados unused ./... # Scanner de segurança gosec ./... # Análise de complexidade gocyclo -over 15 . # Análise de escape go build -gcflags="-m -m" ./... 2>&1 | grep "escapes to heap" # Cobertura de testes go test -coverprofile=coverage.out ./... go tool cover -func=coverage.out ``` --- ## RESUMO FINAL Após concluir a revisão, forneça: 1. **Resumo Executivo**: Visão geral de 2-3 parágrafos 2. **Avaliação de Risco**: Nível de risco geral com justificativa 3. **Top 10 Problemas Críticos**: Lista priorizada 4. **Plano de Ação Recomendado**: Abordagem em fases para correções 5. **Esforço Estimado**: Estimativas de tempo para remediação 6. **Métricas**: - Total de problemas encontrados por severidade - Pontuação de saúde do código (1-10) - Pontuação de segurança (1-10) - Pontuação de segurança de concorrência (1-10) - Pontuação de manutenibilidade (1-10) - Percentual de cobertura de testes