Log e tratamento de erros para um script mais resistente

1. Log

Hoje vamos mergulhar num assunto que pode te economizar muitas células nervosas e tempo precioso – logs e tratamento de erros. Mesmo o programador mais experiente não está imune a erros, e sua missão é tornar esses erros previsíveis e gerenciáveis. Imagine que você é um arqueólogo numa escavação e, para proteger sua expedição de desmoronamentos inesperados e armadilhas traiçoeiras, os logs e o tratamento de erros são sua bússola e escudo nessa jornada arriscada!

Quando falamos de logs em programação, estamos nos referindo ao processo de registrar informações sobre o funcionamento do programa. Isso inclui processos que acontecem dentro do seu código e que podem não ser visíveis à primeira vista. Ao escrever logs, você está deixando dicas para si mesmo, como João e Maria deixaram migalhas de pão na floresta para encontrar o caminho de volta.

Configurando e ajustando logs

Vamos começar com as ferramentas básicas no Python. Para criar logs, usamos o módulo embutido logging. Este é o seu canivete suíço para registrar informações sobre a execução do programa.

import logging

# Configuração de logs
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')

# Exemplo de uso
logging.info("Início do script")
logging.error("Isso é um erro")

        

Quais são os níveis de logging?

• DEBUG: informações super detalhadas, normalmente úteis apenas para diagnosticar problemas.
• INFO: confirma que os processos estão funcionando conforme o esperado.
• WARNING: indica algo inesperado e potencialmente problemático, mas o programa ainda está funcionando.
• ERROR: apenas erros graves que causaram a falha de uma função.

Você pode ajustar o nível de logging para filtrar as informações. Por exemplo, se você só se interessa por erros e avisos, defina o nível como logging.WARNING.

Exemplo de logging com Selenium

Vamos ver como o logging pode ser aplicado em um projeto com Selenium:

from selenium import webdriver

# Configuração de logs
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')

try:
    logging.info("Inicializando o driver do Chrome")
    driver = webdriver.Chrome()
    logging.info("Abrindo a página Python.org")
    driver.get("https://www.python.org")
    logging.info("Execução concluída com sucesso")
except Exception as e:
    logging.error(f"Ocorreu um erro: {e}")
finally:
    driver.quit()

        

Este exemplo demonstra como integrar logging no seu script Selenium para rastrear sua execução. Usamos try, except e finally para tratar erros – mais sobre isso abaixo.

2. Tratamento de erros no Selenium

Na programação, assim como na vida, erros são inevitáveis. No entanto, podemos controlar como reagimos a eles. Usar try, except, else e finally permite capturar e tratar erros de forma elegante.

Revendo o tratamento de exceções

Vamos relembrar como funciona o tratamento de exceções:

try:
    # Código que pode causar uma exceção
    result = 10 / 0
except ZeroDivisionError as e:
    # Código que será executado se a exceção ZeroDivisionError ocorrer
    logging.error("Divisão por zero não é possível!")
else:
    # Código que será executado se nenhuma exceção ocorrer
    logging.info("Operação concluída com sucesso")
finally:
    # Código que será executado em qualquer caso
    logging.info("Operações finalizadas")

        

O código dentro do bloque try será executado. Se ocorrer um erro do tipo ZeroDivisionError, o código no bloco except será executado, e o programa não vai travar. O bloco else é usado para executar código se nenhuma exceção for levantada. E por fim, o bloco finally será sempre executado, independentemente de ter havido erro ou não.

Tratando erros no Selenium

O Selenium fornece várias exceções embutidas para lidar com diferentes situações. Aqui estão algumas exceções úteis e como usá-las.

1. NoSuchElementException — ocorre se o elemento não for encontrado. Use isso para verificar a disponibilidade dos elementos.
   Python

   
   try:
       element = driver.find_element(By.ID, "element_id")
   except NoSuchElementException:
       logging.warning("Elemento com ID 'element_id' não foi encontrado.")
   
                   

2. TimeoutException — ocorre se o elemento esperado não aparecer na página dentro do tempo limite definido. Usado para controlar as esperas.
   Python

   
   from selenium.webdriver.support.ui import WebDriverWait
   from selenium.webdriver.support import expected_conditions as EC
   
   try:
       element = WebDriverWait(driver, 10).until(
           EC.presence_of_element_located((By.ID, "element_id"))
       )
   except TimeoutException:
       logging.error("Esperar pelo elemento com ID 'element_id' falhou.")
   
                   

3. ElementClickInterceptedException — ocorre se o elemento estiver bloqueado por outro elemento e o clique não for possível. Útil ao clicar em elementos que podem estar cobertos por pop-ups.
   Python

   
   from selenium.common.exceptions import ElementClickInterceptedException
   
   try:
       driver.find_element(By.ID, "button_id").click()
   except ElementClickInterceptedException:
       logging.warning("Elemento bloqueado por outro e não pode ser clicado.")
   
                   

Tentativas e lógica de recuperação

Para aumentar a resistência do seu script, você pode implementar um mecanismo de tentativas ao encontrar erros. Por exemplo, se o site estiver temporariamente indisponível ou um elemento não for encontrado, o script pode tentar realizar a ação várias vezes antes de encerrar com um erro.

import time

def retry_find_element(driver, by, value, retries=3):
    attempt = 0
    while attempt < retries:
        try:
            element = driver.find_element(by, value)
            logging.info(f"Elemento encontrado: {value}")
            return element
        except NoSuchElementException:
            attempt += 1
            logging.warning(f"Tentativa {attempt} falhou, tentando novamente em 2 segundos...")
            time.sleep(2)
    logging.error(f"Elemento não encontrado após {retries} tentativas.")
    return None

        

Dicas para scripts mais confiáveis e robustos

• Use esperas explícitas: Configure esperas explícitas para elementos que não aparecem imediatamente. Isso reduz erros devido a atrasos no carregamento.
• Implemente blocos try-except em cada etapa: Isso permite registrar logs de erros e evitar que o script pare devido a pequenas falhas.
• Tente novamente os passos críticos: Se o erro pode ser temporário, configure tentativas com intervalos de alguns segundos.
• Registre logs de cada etapa: Fazer logs de cada etapa chave ajuda a analisar a execução do script e identificar erros escondidos.
• Configure notificações para erros críticos: Por exemplo, envie um e-mail ou mensagem no chat caso um erro de nível CRITICAL seja registrado nos logs.

3. Fazendo bom uso dos logs

Agora que aprendemos a criar logs e tratar erros, vamos dar mais um passo e ver como tirar o máximo proveito dos logs.

Escolhendo o local e formato dos logs

Use arquivos para armazenar logs se quiser mantê-los para análise. É como escrever um diário, que você pode reler e analisar para evitar erros futuros. Vamos configurar o logging para gravar em arquivo:

logging.basicConfig(filename='app.log', filemode='w', level=logging.INFO)

# Agora todos os logs serão salvos em app.log
logging.info("Começando a gravar logs no arquivo.")

        

Analisando os logs

Analise seus logs para identificar erros frequentes ou problemas de desempenho. Talvez seu script tenha problemas apenas em dias ou horários específicos, e isso só pode ser notado com uma análise detalhada dos logs. Essa análise é seu processo investigativo pessoal para entender melhor como sua aplicação funciona.