Monitoramento on Renne Rocha

Monitorando seus projetos de raspagem de dados

blog@rocha.dev.br (Renne Rocha) — Thu, 13 Jan 2022 00:00:00 +0000

Quando passamos a extrair dados de uma página com regularidade, com uma quantidade grande de dados, é muito importante monitorar a saúde dos seus raspadores e a qualidade das informações extraídas.

As páginas podem mudar (as vezes sutilmente), medidas anti-bot podem ser adicionadas e outros problemas temporários e inesperados podem ocorrer e, caso estejamos tratando de uma quantidade grande de scripts retornando milhares de itens, é praticamente impossível monitorar manualmente todo o nosso projeto.

Deste modo, devemos adicionar em nosso projeto, ferramentas que auxiliem no monitoramento.

Spidermon

O Scrapy é um dos principais frameworks para raspagem de dados em Python possuindo diversas bibliotecas e ferramentas que facilitam a criação de projetos de raspagem de dados.

O Spidermon é uma extensão do Scrapy que podemos adicionar ao nosso projeto para facilitar o monitoramento da execução dos seus spiders (como são chamados os scripts que realizam a extração de dados).

Com ela, é possível definir validar dados retornados, monitorar as estatísticas da execução (jobs) de seu spider e, a partir do resultadodessas validações, tomar ações como enviar notificações, gerar relatórios, abrir chamados em sistemas externos quando algo não esteja funcionando corretamente de uma maneira extensível.

O Spidermon pode ser instalado com o pip:

`1`	`pip install spidermon`

Uma vez instalado, precisamos habilitá-lo em nosso projeto Scrapy:

# myproject/settings.py
SPIDERMON_ENABLED = True
EXTENSIONS = {
    "spidermon.contrib.scrapy.extensions.Spidermon": 500,
}

Feito isso, podemos começar a pensar no que será monitorado.

Monitores

É no monitor onde a maioria das validações são definidas. Nele temos acesso as estatísticas e informações das execuções de nossos spiders e podemos definir as nossas regras de monitoramento.

Esse monitor precisa estar dentro de uma suíte de monitores, além de definir um conjunto de ações que devem ser executadas após a execução deles.

Como exemplo, queremos monitorar o número de mensagens de erro emitidas durante os nossos jobs. Isso pode ser feito verificando se o valor dentro da estatística log_count/ERROR é menor a um determinado valor que podemos, por exemplo, definir no arquivo de configuração do nosso projeto.

Um monitor que realiza essa tarefa pode ser definido como:

# myproject/monitors.py
from spidermon import Monitor

class JobErrorsMonitor(Monitor):
    def test_error_count(self):
        num_errors = self.data.stats.get("log_count/ERROR")
        num_errors_threshold = self.data.crawler.settings.getint(
            "MAX_NUM_ERRORS", 0
        )
        if num_errors:
            self.assertTrue(
                num_errors <= num_errors_threshold,
                msg=f"No more than {num_errors_threshold} allowed."
            )

Porém, só definir o monitor não é o suficiente para que esse teste seja rodado ao final da execução do seu spider. Precisamos adicioná-lo a uma suíte de monitores:

# myproject/monitors.py
from spidermon import Monitor, MonitorSuite

class JobErrorsMonitor(Monitor):
    # (...) O código do nosso monitor

class SpiderCloseMonitorSuite(MonitorSuite):
    monitors = [
        JobErrorsMonitor,
    ]

E definir o momento em que momento a suíte será executada, além do nosso valor de referência com o limite da quantidade de erros que aceitamos. Nesse caso, quando o spider terminar sua execução as verificações será feita.

# myproject/settings.py
SPIDERMON_ENABLED = True
EXTENSIONS = {
    "spidermon.contrib.scrapy.extensions.Spidermon": 500,
}
SPIDERMON_SPIDER_CLOSE_MONITORS = (
    "myproject.monitors.SpiderCloseMonitorSuite",
)
MAX_NUM_ERRORS = 10

Ao executar spider podemos ver os resultados desse monitor nos nossos logs:

[scrapy.core.engine] INFO: Closing spider (finished)
[myproject] INFO: [Spidermon] ---------------------- MONITORS ----------------------
[myproject] INFO: [Spidermon] JobErrorsMonitor/test_error_count... OK
[myproject] INFO: [Spidermon] ------------------------------------------------------
[myproject] INFO: [Spidermon] 1 monitor in 0.000s
[myproject] INFO: [Spidermon] OK
[myproject] INFO: [Spidermon] ------------------ FINISHED ACTIONS ------------------
[myproject] INFO: [Spidermon] ------------------------------------------------------
[myproject] INFO: [Spidermon] 0 actions in 0.000s
[myproject] INFO: [Spidermon] OK
[myproject] INFO: [Spidermon] ------------------- PASSED ACTIONS -------------------
[myproject] INFO: [Spidermon] ------------------------------------------------------
[myproject] INFO: [Spidermon] 0 actions in 0.000s
[myproject] INFO: [Spidermon] OK
[myproject] INFO: [Spidermon] ------------------- FAILED ACTIONS -------------------
[myproject] INFO: [Spidermon] ------------------------------------------------------
[myproject] INFO: [Spidermon] 1 action in 0.000s
[myproject] INFO: [Spidermon] OK (skipped=1)

Ou caso aconteça um erro:

[scrapy.core.engine] INFO: Closing spider (finished)
[myproject] INFO: [Spidermon] ---------------------- MONITORS ----------------------
[myproject] INFO: [Spidermon] JobErrorsMonitor/test_error_count... FAIL
[myproject] INFO: [Spidermon] ------------------------------------------------------
[myproject] ERROR: [Spidermon]
======================================================================
FAIL: JobErrorsMonitor/test_error_count
----------------------------------------------------------------------
Traceback (most recent call last):
  File "/home/renne/projects/rennerocha/spidermon/examples/tutorial/tutorial/monitors.py", line 44, in test_error_count
    self.assertTrue(
AssertionError: False is not true : No more than 10 errors allowed.

[myproject] INFO: [Spidermon] 1 monitor in 0.001s
[myproject] INFO: [Spidermon] FAILED (failures=1)
[myproject] INFO: [Spidermon] ------------------ FINISHED ACTIONS ------------------
[myproject] INFO: [Spidermon] ------------------------------------------------------
[myproject] INFO: [Spidermon] 0 actions in 0.000s
[myproject] INFO: [Spidermon] OK
[myproject] INFO: [Spidermon] ------------------- PASSED ACTIONS -------------------
[myproject] INFO: [Spidermon] ------------------------------------------------------
[myproject] INFO: [Spidermon] 0 actions in 0.000s
[myproject] INFO: [Spidermon] OK
[myproject] INFO: [Spidermon] ------------------- FAILED ACTIONS -------------------

Simplificando o nosso monitor

Grande parte dos monitores que precisamos, verifica o valor de uma estatística do seu job com um valor pré-determinado. Por isso, podemos usar a classe BaseStatMonitor com um conjunto definido de atributos para simplificar o nosso código.

O mesmo monitor anterior, verificando se o valor de log_count/ERROR é menor ou igual ao valor definido em MAX_NUM_ERRORS nas configurações do projeto pode ser definido como:

# myproject/monitors.py
from spidermon.contrib.scrapy.monitors import BaseStatMonitor

class JobErrorsMonitor(BaseStatMonitor):
    stat_name = "log_count/ERROR"
    threshold_setting = "MAX_NUM_ERRORS"
    assert_type = "<="

O resultado da execução desse monitor é o mesmo do anterior, porém com um código muito mais simples.

Tornando o monitor mais dinâmico

Não precisamos nos restringir a testes de um valor nas estatísticas em relação a um valor estático definido nas configurações do projeto.

Para isso, ao invés de definir um valor para o atributo threshold_setting, podemos definir o método get_threshold que deverá retornar o valor que será usado como referência para o nosso monitor.

Isso é muito útil por exemplo, quando queremos verificar mais de uma estatística para definir o nosso valor de referência. No exemplo anterior, definimos uma valor fixo aceitável de mensagens de erro durante a execução do nosso spider. Porém termos 10 erros em uma execução que retorna 100k itens (0.001%) pode ser mais aceitável por exemplo do que 10 erros em uma execução que retornou 1k itens (1%).

Então podemos melhoramos o nosso monitor de erros, considerando além da quantidade de erros, a quantidade de itens retornados. Desse modo só haverá falha se o número de erros for menor do que 0.001% da quantidade de itens retornados.

# myproject/monitors.py
from spidermon.contrib.scrapy.monitors import BaseStatMonitor

class JobErrorsMonitor(BaseStatMonitor):
    stat_name = "log_count/ERROR"
    assert_type = "<="

    def get_threshold(self):
        item_scraped_count = self.data.stats.get(
            "item_scraped_count"
        )
        return item_scraped_count * 0.0001

Podemos também buscar dados de fontes externas, comparar com dados de execuções passadas que estejam armazenados em um banco de dados ou fazer cálculos mais complexos para definir o nosso valor de referência.

O importante é que sempre o retorno do método get_threshold seja um valor que possa ser usado na comparação com a estatística que queremos.

Na documentação é possível encontrar mais exemplo e opções para os nossos monitores, além de um conjunto de monitores pré-definidos para as validações mais comuns nos projetos diminuindo a quantidade de código que precisamos escrever para começar a monitorar nossos projetos.

Próximos passos

Ver o resultado dos nossos monitores apenas nos logs não é muito prático. O que precisamos fazer em seguida é configurar nosso projeto para que alguma ação seja tomada em caso de falha (ou de sucesso).

Para isso, precisamos definir actions. Na extensão temos integrações prontas para receber notificações por e-mail, Slack, Telegram ou Sentry, além de ser possível criar suas próprias ações de acordo com as necessidades do projeto.

Na documentação é possível encontrar mais informações sobre como defini-las e configurá-las.

Validando dados extraídos com Scrapy

blog@rocha.dev.br (Renne Rocha) — Fri, 08 Mar 2019 00:00:00 +0000

Como você garante a qualidade e a confiabilidade dos dados que você está extraindo em seu crawler?

Se o seu crawler foi desenvolvido com Scrapy, você tem a disposição a extensão Spidermon, que junto com a biblioteca Schematics permite que você inclua validações de dados de maneira simples e altamente customizável.

Definindo modelos de dados, é possível comparar os items retornados com uma estrutura pré-determinada, garantido que todos os campos contém dados no formato esperado.

Nosso exemplo

Para explicar o uso do Spidermon para realizar a validação dos dados, criamos um projeto de exemplo simples, que extrai citações do site http://quotes.toscrape.com/.

Começamos instalando as bibliotecas necessárias:

1
2
3

$ python3 -m venv .venv
$ source .venv/bin/activate
(.venv) $ pip install scrapy spidermon schematics

Em seguida criamos um novo projeto Scrapy:

1
2

$ scrapy startproject quotes_crawler
$ cd myproject & scrapy genspider quotes quotes.com

Definimos um item que será retornado pelo nosso spider:

# quotes_crawler/spiders/items.py
import scrapy

class QuoteItem(scrapy.Item):
    quote = scrapy.Field()
    author = scrapy.Field()
    author_url = scrapy.Field()
    tags = scrapy.Field()

E finalmente criamos o nosso spider:

# quotes_crawler/spiders/quotes.py
import scrapy
from myproject.items import QuoteItem

class QuotesSpider(scrapy.Spider):
    name = "quotes"
    allowed_domains = ["quotes.toscrape.com"]
    start_urls = ["http://quotes.toscrape.com/"]

    def parse(self, response):
        for quote in response.css(".quote"):
            item = QuoteItem(
                quote=quote.css(".text::text").get(),
                author=quote.css(".author::text").get(),
                author_url=response.urljoin(
                    quote.css(".author a::attr(href)").get()),
                tags=quote.css(".tag *::text").getall(),
            )
            yield item
        yield scrapy.Request(
            response.urljoin(response.css(
                ".next a::attr(href)").get())
        )

Com isso já é possível executar o nosso crawler e obter os dados desejados:

`1`	`$ scrapy crawl quotes -o quotes.csv`

Definindo nosso modelo de validação

Schematics é uma biblioteca de validação de dados baseada em modelos (muito parecidos com modelos do Django). Esses modelos incluem alguns tipos de dados comuns e validadores, mas também é possível extendê-los e definir regras de validação customizadas.

Baseado no nosso exemplo anterior, vamos criar um modelo para o nosso item contendo algumas regras básicas de validação:

# quotes_crawler/spiders/validators.py
from schematics.models import Model
from schematics.types import URLType, StringType, ListType

class QuoteItem(Model):
    # String de preenchimento obrigatório
    quote = StringType(required=True)

    # String de preenchimento obrigatório
    author = StringType(required=True)

    # Uma string que represente uma URL de preenchimento obrigatório
    author_url = URLType(required=True)

    # Lista de Strings de preenchimento não obrigatório
    tags = ListType(StringType)

Precisamos agora habilitar o Spidermon e configurá-lo para que os campos retornados pelo nosso spider sejam validados contra esse modelo:

# quotes_crawler/settings.py
SPIDERMON_ENABLED = True

EXTENSIONS = {
    "spidermon.contrib.scrapy.extensions.Spidermon": 500,
}

ITEM_PIPELINES = {
    "spidermon.contrib.scrapy.pipelines.ItemValidationPipeline": 800
}

SPIDERMON_VALIDATION_MODELS = (
    "quotes_crawler.validators.QuoteItem",
)

# Inclui um campo '_validation' nos items que contenham erros
# com detalhes do problema encontrado
SPIDERMON_VALIDATION_ADD_ERRORS_TO_ITEMS = True

Conforme os dados forem extraidos, eles serão validados de acordo com as regras definidas no modelo e, caso algum erro seja encontrado, um novo campo _validation será incluído no item com detalhes do erro.

Caso um item receba uma URL inválida no campo author_url por exemplo, o resultado será:

{
    '_validation': defaultdict(
        <class 'list'>, {'author_url': ['Invalid URL']}),
    'author': 'C.S. Lewis',
    'author_url': 'invalid_url',
    'quote': 'Some day you will be old enough to start reading fairy tales '
        'again.',
    'tags': ['age', 'fairytales', 'growing-up']
}