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 usado em conjunto com instruções personalizadas, Revisão de código com Copilot é mais eficaz porque pode fornecer respostas adaptadas à maneira como sua equipe funciona, às ferramentas que você usa 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 o 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 sua project. 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-lhe 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 Autofixo do Copilot 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 GitHub e encontrar vulnerabilidades de segurança e erros de codificação, o Autofixo do Copilot pode então sugerir correções para alertas, permitindo que você evite e reduza vulnerabilidades de maneira mais eficiente.
Por exemplo, Autofixo do Copilot 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 Autofixo do Copilot 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. Autofixo do Copilot permite que você se concentre na compreensão da segurança na codificação 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 nossas necessidades de projeto e de usuário e também vimos como podemos adaptar a quantidade de explicação que o 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 Autofixo do Copilot 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 deixar suas revisões mais eficientes e eficazes usando os recursos de revisão do Copilot, siga estas etapas para começar.
- Crie instruções personalizadas específicas para seu project 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 Configurando a revisão automática de código por GitHub Copilot.
- Para configurar o Autofixo do Copilot 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 Autofixo do Copilot 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.