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 automáticas de Copilot podem ajudar a otimizar seu processo de revisão para que você gaste menos tempo em pequenas alterações e mais tempo na resolução de problemas complexos e na obtenção de uma compreensão mais profunda, garantindo uma implementação que não seja apenas adequada, mas que atenda habilmente às necessidades do usuário.
1. Melhorar a qualidade da revisão de Copilot
Copilot revisão de código pode fornecer revisões automatizadas para todas as solicitações de pull em seu repositório e tornar a revisão mais eficiente capturando as alterações que você não deseja em seu código. Quando emparelhado com instruções personalizadas, é mais eficaz porque Copilot revisão de código 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 Python, suas instruções personalizadas poderão incluir práticas de formatação, desempenho e codificação seguras específicas 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, veremos como nossas instruções personalizadas de exemplo podem afetar positivamente os comentários de revisão que o Copilot fornece para um pull request.
2. Automatizar revisões para abordar convenções de estilo e desempenho
Quando a revisão automática Copilot revisão de código estiver habilitada, Copilot examinará automaticamente uma solicitação de pull assim que sair 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.
Copilot examinaria o código e poderia fazer a seguinte sugestão de comentário e código.
Observação
A resposta a seguir é um exemplo. Respostas do Bate-Papo 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 de Copilot segue as diretrizes de suas instruções personalizadas em sua 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 registro em log de erros, explicando concisamente o raciocínio por trás das sugestões.
Observação
Sempre examine cuidadosamente as sugestões de Copilot antes de aceitar e se comprometer.
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 Copilot revisão de código possa fazer sugestões de práticas recomendadas de segurança, Copilot Autofix para code scanning levar isso um passo adiante. Aproveitar os recursos dos code scanning juntamente com a análise CodeQL para analisar o código em um repositório GitHub e encontrar vulnerabilidades de segurança e erros de codificação; Copilot Autofix pode então sugerir correções para alertas, permitindo que você evite e reduza vulnerabilidades de forma mais eficaz.
Por exemplo, Copilot Autofix pode 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.
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 Copilot sugeridas antes de aceitá-las.
- Neste exemplo, Copilot revisão de código também pode destacar a necessidade de gerar sais exclusivos.
Como você pode ver, identificar vulnerabilidades automaticamente, juntamente com sugestões para corrigi-las, ajuda você a tornar a segurança uma prioridade. Copilot Autofix permite que você se concentre em entender a codificação segura e as 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 modo que fossem específicas às necessidades do Copilot revisão de código nosso projeto e do usuário e também vimos como podemos adaptar a quantidade de explicação Copilot fornecida nos comentários.
-
Copilot revisão de código nos ajudou a melhorar rapidamente nosso log de erros e entender por que isso importava. -
Copilot Autofix para code scanning nos ajudou a evitar que usássemos uma abordagem insuficiente de hashing de senhas e a proteger os dados dos usuários.
Próximas etapas
Para tornar suas revisões mais eficientes e eficazes usando Copilotos recursos de revisão, comece seguindo estas etapas.
- 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 habilitar automaticamente Copilot revisão de código para seu repositório, consulte Configurando a revisão automática de código GitHub Copilot.
- Para configurar Copilot Autofix para o repositório, você precisará habilitar code scanning. Depois que a análise CodeQL estiver habilitada com code scanning, Copilot Autofix será 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.