Introdução
As revisões de código são mais eficientes quando você gasta menos tempo em detalhes de implementação menores, como convenções de nomenclatura e estilo, e, em vez disso, concentra seu esforço em design de nível superior, resolução de problemas e funcionalidade que atenda às necessidades do usuário.
Neste artigo, mostraremos como as revisões automatizadas do Copilot podem ajudar a otimizar o processo de revisão para que você gaste menos tempo em alterações menores e mais tempo na resolução de problemas com nuances e na compreensão mais aprofundada da implementação que não seja simplesmente adequada, mas atenda habilmente às necessidades dos usuários.
1. Melhorar a qualidade da revisão de Copilot
A Revisão de código com Copilot pode fornecer revisões automatizadas para todas as pull requests em seu repositório e tornar a revisão mais eficiente identificando as alterações indesejadas no código. Quando emparelhado com instruções personalizadas, Revisão de código com Copilot se torna mais eficaz, pois é capaz de fornecer respostas adaptadas à forma como sua equipe trabalha, às ferramentas que utiliza ou às especificidades do seu projeto.
As práticas recomendadas para escrever instruções personalizadas incluem:
- Títulos distintos
- Marcadores
- Instruções curtas e diretas
Vamos examinar um exemplo. Se você estiver criando um sistema de processamento de pedidos usando Python, suas instruções personalizadas poderão incluir práticas de formatação, desempenho e codificação seguras específicas do Python, bem como diretrizes diretamente relevantes para seu projeto. O exemplo a seguir mostra como podem ser algumas das linhas de suas instruções personalizadas.
## Repository context
- This repository implements an order processing system (order intake, payment, fulfillment) where correctness, security, and auditability are critical.
## Style and conventions
- Follow the PEP 8 and PEP 257 style guide for Python.
- Use clear, domain-relevant names (orders, payments, inventory, customers, shipments).
- Prefer small, focused functions and methods with clearly defined responsibilities.
## Secure coding
- Verify proper input validation and sanitization.
- Review authentication and authorization logic.
## Error handling guidelines
- Handle timeouts and network errors gracefully.
- Ensure failures are logged with enough detail for debugging.
## Order processing context
- Ensure order creation, payment handling, and updates are idempotent to avoid duplicate orders or duplicate charges.
- Validate and normalize all order, payment, and customer data before persisting or acting on it.
- Do not log or persist sensitive data (passwords, raw payment details, full identifiers) without hashing, encryption, or redaction.
- Call out obvious performance issues in core order workflows (e.g., N+1 queries, per-order synchronous network calls) and suggest simpler, more efficient alternatives.
## Review style
- Be concise, specific and actionable.
- Explain the "why" behind recommendations using bullet points.
Na próxima seção, examinaremos como nossas instruções personalizadas de exemplo podem impactar positivamente os comentários de revisão que o Copilot fornece para uma pull request.
2. Automatizar revisões para abordar convenções de estilo e desempenho
Quando a Revisão de código com Copilot automático estiver habilitada, o Copilot revisará automaticamente uma pull request quando ela estiver fora do modo de rascunho.
Imagine que você envie uma solicitação de pull que inclua a função a seguir para atualizar o inventário em seu sistema de processamento de pedidos.
def notify_inventory(product_id, quantity):
requests.post("http://inventory-service/update", json={"product_id": product_id, "quantity": quantity})
Embora isso seja funcional, falta clareza e robustez. A intenção dos tipos é implícita, não há docstrings e não inclui tratamento de erros ou registro em log, o que não deixa claro se a notificação realmente funcionou.
O Copilot examinaria o código e poderia fazer o comentário e a sugestão de código a seguir.
Observação
A resposta a seguir é um exemplo. Respostas do Chat Copilot são não determinísticas, portanto, você pode obter uma resposta diferente da mostrada aqui.
Missing error handling for network calls
The notify_inventory function makes a synchronous network call without any error handling for timeouts, connection failures, or non-200 responses.
Why this matters:
- Network failures will cause unhandled exceptions and crash the order processing flow
- Orders could be marked as CONFIRMED but inventory never gets updated
- This violates the requirement to "handle timeouts and network errors gracefully"
- Failures won't be logged with enough detail for debugging
Recommendation: Add proper error handling with timeout and logging:
def notify_inventory(product_id: str, quantity: int) -> bool:
"""Notify the inventory service of order placement.
Args:
product_id: The product identifier.
quantity: The quantity ordered.
Returns:
True if the notification succeeded; False otherwise.
"""
try:
response = requests.post(
"http://inventory-service/update",
json={"product_id": product_id, "quantity": quantity},
timeout=5,
)
response.raise_for_status()
logger.info(
"Inventory notified for product %s, quantity %d (status %d)",
product_id,
quantity,
response.status_code,
)
return True
except requests.exceptions.Timeout:
logger.error(
"Timeout notifying inventory for product %s, quantity %d",
product_id,
quantity,
exc_info=True,
)
except requests.exceptions.RequestException:
logger.error(
"Failed to notify inventory for product %s, quantity %d",
product_id,
quantity,
exc_info=True,
)
return False
A resposta do Copilot segue as orientações das instruções personalizadas na recomendação. Neste exemplo, ele segue as diretrizes de estilo PEP 8 e 257 para Python e sugere uma melhoria para lidar melhor com tempos limite e log de erros, explicando concisamente o raciocínio por trás das sugestões.
Observação
Sempre examine cuidadosamente as sugestões do Copilot antes de aceitar e efetuar a confirmação.
Comentários de revisão automática como esses dão suporte a você na criação de seu próprio entendimento quando você está codificando ou pode ajudá-lo a concentrar e restringir os comentários dados a outras pessoas ao revisar.
3. Sinalizar vulnerabilidades de segurança e corrigi-las
Em seguida, imagine que você foi encarregado de melhorar a forma como as senhas são armazenadas em seu sistema de processamento de pedidos. Você envia uma pull request com o código que achou que estava suficientemente seguro por meio de hash nas senhas de usuário a fim de protegê-las.
def get_password_hash(password: str, salt: str) -> str:
"""Hash a password with the given salt using SHA-256.
Returns the hexadecimal representation of the hashed password.
"""
return hashlib.sha256((password + salt).encode()).hexdigest()
class User:
"""Represents a user in the order processing system."""
def __init__(self, username: str, password: str, salt: str):
"""Initialize a User with username, password, and salt.
The password is hashed and stored for authentication.
"""
self.username = username
self.salt = salt
self.password_hash = get_password_hash(password, self.salt)
def verify_password(self, password: str) -> bool:
"""Verify a plain-text password against the stored hash."""
return get_password_hash(password, self.salt) == self.password_hash
No entanto, neste exemplo, o uso do SHA-256 não é aceitável, pois não é computacionalmente caro o suficiente para proteger senhas de usuário.
Embora a Revisão de código com Copilot possa fazer sugestões de práticas recomendadas de segurança, o Copilot Autofix para code scanning leva isso um passo adiante. Aproveitando os recursos de code scanning com a análise CodeQL para examinar o código em um repositório do e encontrar vulnerabilidades de segurança e erros de codificação, o Copilot Autofix pode então sugerir correções para alertas, permitindo que você evite e reduza vulnerabilidades de maneira mais eficiente.
Por exemplo, Copilot Autofix irá fazer o seguinte comentário sobre o código.
Using SHA-256 for password hashing is insecure for authentication systems. SHA-256 is designed to be fast, making it vulnerable to brute-force attacks.
To fix the problem, use a password-specific hashing algorithm like bcrypt, scrypt, or argon2 (e.g., `argon2-cffi` from the PyPI package) which are designed to be slow and include built-in salting mechanisms.
O Copilot Autofix também fará sugestões de código para uma possível correção da vulnerabilidade para você examinar. Nesse caso, pode fazer sugestões de código, como as abaixo, para importar um pacote e atualizar o código relacionado ao hash da senha.
from argon2 import PasswordHasher
def get_initial_hash(password: str):
ph = PasswordHasher()
return ph.hash(password)
def check_password(password: str, known_hash):
ph = PasswordHasher()
return ph.verify(known_hash, password)
Observação
- Sempre verifique e valide as alterações sugeridas por Copilot antes de aceitá-las.
- Neste exemplo, a Revisão de código com Copilot também pode destacar a necessidade de gerar saltos exclusivos.
Como você pode ver, identificar vulnerabilidades automaticamente, juntamente com sugestões para corrigi-las, ajuda você a tornar a segurança uma prioridade. O Copilot Autofix permite que você foque na compreensão da codificação segura e nas correções que funcionam melhor para sua base de código e projeto.
Revisões otimizadas com Copilot
Comentários de revisão automática ajudam você a otimizar suas revisões e proteger seu código com mais eficiência, independentemente do nível de experiência.
- Instruções personalizadas ajudaram a refinar as respostas de Revisão de código com Copilot para que fossem específicas às necessidades do nosso projeto e do usuário, e também vimos como podemos adaptar o nível de detalhe nas explicações que Copilot fornece em feedback.
- O Revisão de código com Copilot nos ajudou a melhorar rapidamente nosso registro de erros e entender por que ele importava.
- O Copilot Autofix para code scanning nos ajudou a evitar o uso de uma abordagem insuficiente de hash de senha e proteger os dados do usuário.
Próximas etapas
Para tornar suas revisões mais eficientes e eficazes utilizando os recursos de revisão do Copilot, comece seguindo os passos abaixo.
- Crie instruções personalizadas específicas para seu projeto e repositório. Escreva sua própria ou inspire-se em nossa biblioteca de exemplos. Confira Instruções personalizadas.
- Para ativar o Revisão de código com Copilot automático para o seu repositório, consulte Configurar a revisão automática do GitHub Copilot.
- Para configurar o Copilot Autofix para o seu repositório, você precisará habilitar o recurso code scanning. Uma vez que o recurso code scanning com CodeQL análise estiver habilitado, o Copilot Autofix estará habilitado por padrão. Para obter a configuração mais fácil, consulte Como definir a configuração padrão da verificação de código.
Leitura adicional
Para ir mais fundo com a revisão do código gerado por IA, consulte Examinar o código gerado por IA.