Scrapy Log Dosyalarını Dinamik Yönetme: Her Spider İçin Özel Kayıt

Scrapy projeleri geliştikçe ve kapsamları genişledikçe, log yönetimi genellikle göz ardı edilen ancak kritik öneme sahip bir konudur. Birden fazla spider’ın aynı anda çalıştığı durumlarda, tüm kayıtların tek bir dosyada toplanması hata ayıklamayı ve performans izlemeyi gerçek bir kabusa dönüştürebilir. Peki, her bir Scrapy spider’ı için dinamik olarak ayrı bir log dosyası oluşturarak bu karmaşayı nasıl ortadan kaldırabiliriz? Bu makale, web kazıma projelerinizin daha düzenli, yönetilebilir ve hata ayıklaması kolay hale gelmesi için adım adım bir rehber sunuyor. Böylece, loglarınızla boğuşmak yerine veri toplamaya odaklanabilirsiniz.

Modern web kazıma projeleri, genellikle onlarca, hatta yüzlerce farklı web sitesinden veri toplamak üzere tasarlanmış çok sayıda Scrapy spider’ı içerir. Her bir spider’ın kendine özgü davranışları, veri toplama stratejileri ve karşılaşabileceği özel hatalar vardır. Başlangıçta, tüm logların tek bir konsola veya ortak bir dosyaya yazılması pratik gibi görünse de, proje büyüdükçe bu yaklaşım hızla sürdürülemez hale gelir. Düşünsenize, aynı anda çalışan yirmi farklı spider’ınız var ve aniden bir hata raporu alıyorsunuz. Hangi spider’ın hata verdiğini, hatanın tam olarak ne zaman ve hangi bağlamda oluştuğunu anlamak için devasa bir log dosyasını taramak zorunda kalmak, verimliliğinizi düşüren ve geliştirme sürecini yavaşlatan korkunç bir deneyim olabilir. Bu durum, özellikle gerçek zamanlı hata tespiti veya performans darboğazlarını analiz etme ihtiyacı doğduğunda daha da belirginleşir.

Tek bir log dosyasında tüm spider’ların karışık kayıtlarını görmek, adeta bir bilgi karmaşası yaratır. Örneğin, bir e-ticaret sitesinden ürün fiyatlarını çeken spider’ınızın yavaş çalıştığını fark ettiğinizde, diğer spider’ların ağ istekleri veya sayfa ayrıştırma (parsing) hataları arasında, ilgili performansı düşüren satırları bulmak iğneyle kuyu kazmak gibidir. Bu durum, sadece zaman kaybettirmekle kalmaz, aynı zamanda potansiyel hataların gözden kaçmasına ve dolayısıyla projenizin genel güvenilirliğinin azalmasına yol açabilir. İşte tam da bu noktada, her bir Scrapy spider’ı için dinamik olarak ayrı bir log dosyası oluşturmanın önemi ortaya çıkar. Bu sayede, her spider kendi “günlüğünü” tutar ve bu da sorunları anlama, giderme ve performansı optimize etme sürecini kökten basitleştirir. Bu yaklaşım, sadece hata ayıklama sürecini hızlandırmakla kalmaz, aynı zamanda projelerinizin uzun vadeli bakımı ve ölçeklenebilirliği açısından da vazgeçilmez bir stratejidir.

Bu makale boyunca, Scrapy’nin güçlü Python logging modülünü nasıl kullanarak her spider’ınız için özel log dosyaları oluşturacağınızı, bu dosyaları nasıl yöneteceğinizi ve kayıtlarınızı daha anlamlı hale getirmek için hangi özelleştirmeleri yapabileceğinizi adım adım inceleyeceğiz. Amacımız, Scrapy projelerinizde log yönetimini bir zorluktan ziyade, güçlü bir hata ayıklama ve izleme aracına dönüştürmektir.

Temel Kavramlar: Python’ın Logging Modülü ve Scrapy ile Entegrasyonu Nasıl Çalışır?

Dinamik loglama stratejilerine geçmeden önce, Scrapy’nin temelinde yatan Python’ın logging modülünü ve bu modülün Scrapy ile nasıl entegre olduğunu anlamak hayati öneme sahiptir. Python’ın logging modülü, uygulamalarınızda olayları izlemek için esnek ve güçlü bir çerçeve sunar. Bu olaylar, bir programın durumunu, hata mesajlarını, uyarıları veya yalnızca bilgilendirme amaçlı mesajları içerebilir. Modülün temelinde dört ana bileşen bulunur:

1. Logger’lar: Uygulamanızda log mesajları üreten ana giriş noktalarıdır. Hiyerarşik bir yapıya sahiptirler ve farklı modüller veya işlevler için farklı logger’lar tanımlanabilir.
2. Handler’lar: Logger’lar tarafından üretilen log mesajlarını alır ve belirli bir hedefe (konsol, dosya, ağ soketi, e-posta vb.) yönlendirir. Örneğin, StreamHandler mesajları konsola yazarken, FileHandler bir dosyaya yazar.
3. Formatter’lar: Log mesajlarının son çıktısını (formatını) belirler. Tarih/saat, log seviyesi, dosya adı, satır numarası gibi bilgileri mesajın içine dahil edebilirler.
4. Filter’lar: Handler’lara ulaşmadan önce log mesajlarını filtrelemek için kullanılır. Belirli koşulları karşılamayan mesajların işlenmesini engelleyebilirler.

Scrapy, varsayılan olarak bu logging modülünü kapsamlı bir şekilde kullanır. Projenizi çalıştırdığınızda, Scrapy arka planda bir varsayılan logger oluşturur ve bu logger genellikle log mesajlarını konsola (StreamHandler aracılığıyla) yazdırır. Ayrıca, LOG_FILE ayarını kullanarak tüm Scrapy loglarını tek bir dosyaya yönlendirme seçeneği de sunar. Bu, küçük projeler için yeterli olabilir, ancak yukarıda bahsedilen ölçeklenebilirlik sorunlarına yol açar. Scrapy’nin settings.py dosyasındaki bazı önemli log ayarları şunlardır:

• LOG_ENABLED = True: Loglamayı etkinleştirir veya devre dışı bırakır.
• LOG_LEVEL = 'DEBUG': Logların seviyesini belirler (DEBUG, INFO, WARNING, ERROR, CRITICAL). Varsayılan olarak DEBUG en düşük seviyedir ve tüm mesajları gösterir.
• LOG_FILE = 'my_spider.log': Tüm logları belirtilen dosyaya yazar.
• LOG_FORMAT = '%(asctime)s [%(name)s] %(levelname)s: %(message)s': Log mesajlarının formatını belirler.
• LOG_DATEFORMAT = '%Y-%m-%d %H:%M:%S': Logdaki zaman damgasının formatını belirler.

Varsayılan Scrapy loglama entegrasyonu, tüm logları tek bir global logger üzerinden yönetir. Bu, farklı spider’lar arasında ayrım yapmayı zorlaştırır. İşte bu yüzden, her spider’a özel bir loglama mekanizması eklemek için Python’ın logging modülünün esnekliğinden faydalanmamız gerekir. Bu, her spider’ın kendi logger’ını, handler’ını ve formatter’ını oluşturmasını sağlayarak, log mesajlarının belirli bir spider’a ait olduğunu kesin olarak bilmemizi mümkün kılar. Böylece, devasa bir log dosyasında bir spider’ın kayıtlarını aramak yerine, doğrudan o spider’ın özel log dosyasına bakarak çok daha hızlı ve etkili bir şekilde sorunları tespit edebiliriz.

Bir sonraki bölümde, bu temel bilgileri kullanarak her spider için nasıl dinamik olarak ayrı log dosyaları oluşturacağımızı adım adım ele alacağız ve bu sayede Scrapy projelerinizin loglama yeteneklerini bir üst seviyeye taşıyacağız.

Her Spider İçin Özel Log Dosyası Oluşturma: Adım Adım Rehber

Scrapy projelerinizde her spider için ayrı bir log dosyası oluşturmak, proje yönetimini ve hata ayıklamayı önemli ölçüde kolaylaştırır. Bu süreci, Python’ın logging modülünün gücünü kullanarak adım adım nasıl uygulayacağınızı inceleyelim. Temel fikir, her spider’ın kendisi başlatıldığında (veya Scrapy uzantısı aracılığıyla), kendi özel logger’ını, dosya handler’ını ve formatter’ını ayarlamasıdır.

1. Adım: Scrapy’nin Varsayılan Dosya Loglamasını Devre Dışı Bırakın

Öncelikle, Scrapy’nin tüm logları tek bir dosyaya yazma davranışını engellememiz gerekiyor. Bunu settings.py dosyanızda yaparak global loglama davranışını özelleştiriyoruz:

# settings.py
# Varsayılan dosya loglamasını kapat
LOG_FILE = None
# Log seviyesini uygun bir değere ayarla
LOG_LEVEL = 'INFO' # Yalnızca önemli bilgileri ve hataları görmek için 'INFO' veya 'WARNING' idealdir

LOG_FILE = None olarak ayarlamak, Scrapy'nin tüm logları tek bir dosyaya yazmasını engeller. LOG_LEVEL'ı ise, varsayılan olarak Scrapy tarafından konsola (eğer başka bir handler eklemezseniz) veya diğer özel handler'lara gönderilecek mesajların minimum seviyesini belirler. Bu, gereksiz debug mesajlarının genel log akışını kirletmesini önlemek için önemlidir.

2. Adım: Her Spider İçin Özel Bir Logger ve FileHandler Oluşturun

Şimdi sıra, her spider'ın kendi özel log mekanizmasını nasıl kuracağına geliyor. Bu genellikle spider sınıfının __init__ metodu içinde yapılır. Aşağıdaki örnek, MySpider adında bir spider için nasıl özel bir log dosyası oluşturulacağını gösteriyor:

# my_spider.py
import logging
import os
from scrapy import Spider

class MySpider(Spider):
    name = 'my_spider'
    start_urls = ['http://quotes.toscrape.com/']

    custom_settings = {
        'LOG_LEVEL': 'INFO', # Bu spider için özel log seviyesi
    }

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        
        # Log dosyasının kaydedileceği dizini oluştur
        log_dir = 'logs'
        if not os.path.exists(log_dir):
            os.makedirs(log_dir)

        # Spider'a özel log dosyası adı oluştur
        log_file_name = os.path.join(log_dir, f'{self.name}.log')

        # Yeni bir logger örneği al veya oluştur
        self.logger = logging.getLogger(self.name)
        self.logger.setLevel(logging.INFO) # Bu logger için minimum log seviyesi

        # Tüm mevcut handler'ları temizle (isteğe bağlı ama karışıklığı önler)
        if not self.logger.handlers: # Sadece henüz handler atanmamışsa ekle
            # Bir FileHandler oluştur ve log dosyasını belirt
            file_handler = logging.FileHandler(log_file_name, mode='a', encoding='utf-8')
            file_handler.setLevel(logging.INFO) # Dosya handler'ı için minimum log seviyesi

            # Log formatını belirle
            formatter = logging.Formatter(
                '%(asctime)s - %(name)s - %(levelname)s - %(message)s',
                datefmt='%Y-%m-%d %H:%M:%S'
            )
            file_handler.setFormatter(formatter)

            # FileHandler'ı logger'a ekle
            self.logger.addHandler(file_handler)

            # Opsiyonel: Konsol loglamayı da eklemek isterseniz
            # console_handler = logging.StreamHandler()
            # console_handler.setLevel(logging.DEBUG)
            # console_handler.setFormatter(formatter)
            # self.logger.addHandler(console_handler)

        # Scrapy'nin kendi logger'ına aynı handler'ları eklemeyi önlemek için
        # Scrapy'nin root logger'ına propagasyonu kapat (çoğu durumda tercih edilir)
        self.logger.propagate = False 

    def parse(self, response):
        self.logger.info(f'URL {response.url} başarıyla işlendi.')
        quotes = response.css('div.quote')
        for quote in quotes:
            text = quote.css('span.text::text').get()
            author = quote.css('small.author::text').get()
            self.logger.debug(f'Alıntı bulundu: "{text[:30]}..." yazar: {author}')
            yield {
                'text': text,
                'author': author,
            }

        next_page = response.css('li.next a::attr(href)').get()
        if next_page is not None:
            self.logger.info(f'Sonraki sayfa bulunuyor: {next_page}')
            yield response.follow(next_page, callback=self.parse)
        else:
            self.logger.info('Tüm sayfalar işlendi, sonraki sayfa yok.')

Yukarıdaki kodda dikkat edilmesi gereken bazı noktalar:

• os.path.join(log_dir, f'{self.name}.log'): Her spider için, adını kullanarak benzersiz bir log dosyası adı oluştururuz. Bu, logs/my_spider.log gibi bir dosya oluşturur.
• logging.getLogger(self.name): Spider'ın adı ile özel bir logger alırız. Bu, log mesajlarının hangi spider'dan geldiğini açıkça belirtir.
• self.logger.propagate = False: Bu satır çok önemlidir. Varsayılan olarak, bir logger'dan gelen mesajlar hiyerarşik olarak üst logger'lara (root logger dahil) "yayılarak" gönderilir. Eğer bunu False yapmazsanız, sizin özel handler'larınızın yanı sıra Scrapy'nin varsayılan handler'ları da aynı mesajları işleyebilir ve bu da loglarınızın tekrar etmesine neden olabilir.
• if not self.logger.handlers:: Bu kontrol, __init__ metodunun birden fazla çağrılması durumunda (örneğin Scrapy'nin farklı bileşenleri tarafından) aynı handler'ların logger'a tekrar tekrar eklenmesini önler. Bu da loglarınızın ikişer kez yazılmasını engeller.

Vaka Analizi: E-ticaret Ürün Veri Kazıma Senaryosu

Bir e-ticaret platformunda farklı kategorilerdeki ürün verilerini çeken üç ayrı spider'ınız olduğunu düşünün: ElectronicsSpider, ClothingSpider ve BooksSpider. Her birinin kendine ait binlerce ürünü işlediği ve kendi hatalarıyla karşılaşabileceği bir senaryo hayal edin.

Bu dinamik loglama yaklaşımı sayesinde:

• logs/electronics_spider.log
• logs/clothing_spider.log
• logs/books_spider.log

gibi ayrı log dosyalarına sahip olursunuz. Diyelim ki ClothingSpider beklenmedik bir şekilde durdu. Yapmanız gereken tek şey logs/clothing_spider.log dosyasını açıp son kaydedilen hata mesajlarına bakmaktır. Tüm logların içinden ilgili satırları ayıklamak için saatler harcamak yerine, dakikalar içinde sorunu tespit edip çözüme odaklanabilirsiniz. Bu, özellikle büyük ölçekli ve kritik veri kazıma operasyonlarında zaman ve kaynak tasarrufu sağlar.

Bu adımlarla, Scrapy projelerinizde her spider için özel, dinamik log dosyaları oluşturmanın temelini atmış olursunuz. Bir sonraki bölümde, bu loglama yapısını daha da geliştirerek log formatlarını ve seviyelerini nasıl özelleştirebileceğinizi inceleyeceğiz.

Log Formatlamayı ve Seviyelerini Özelleştirme: Daha Anlamlı Kayıtlar Nasıl Tutulur?

Loglama sadece mesaj kaydetmekten ibaret değildir; kaydedilen mesajların okunabilirliği, anlaşılabilirliği ve analizi de büyük önem taşır. Python'ın logging modülü ve dolayısıyla Scrapy, log mesajlarının formatını ve hangi seviyedeki mesajların kaydedileceğini (veya gösterileceğini) özelleştirme konusunda geniş seçenekler sunar. Bu özelleştirmeler, log dosyalarınızın gerçek bir bilgi kaynağı haline gelmesini sağlar.

Log Seviyeleri: Ne Zaman Ne Kaydedilmeli?

Python logging modülü, mesajları önem derecelerine göre kategorize etmek için standart log seviyeleri tanımlar. Bu seviyeler, bir olayın ciddiyetini veya türünü belirtir:

Her logger ve handler için ayrı ayrı setLevel() metodunu kullanarak hangi seviyedeki mesajları işleyeceklerini belirleyebilirsiniz. Örneğin, üretim ortamında sadece INFO ve üzeri mesajları kaydetmek, geliştirme ortamında ise DEBUG seviyesini etkinleştirmek yaygın bir pratiktir.

# Spider init metodu içinde
self.logger.setLevel(logging.INFO) # Logger seviyesi
file_handler.setLevel(logging.WARNING) # Dosya handler'ı sadece WARN ve üzeri mesajları kaydetsin

Yukarıdaki örnekte, spider'ın logger'ı INFO ve üzeri tüm mesajları işlerken, file_handler sadece WARNING ve üzeri mesajları log dosyasına yazacaktır. Bu sayede, konsolda daha fazla detay görürken, dosya logunda yalnızca kritik sorunları tutabilirsiniz.

Custom Formatters: Log Mesajlarını Daha Anlamlı Hale Getirme

Bir Formatter kullanarak log mesajlarının nasıl görüneceğini belirleyebilirsiniz. Bu, hata ayıklama ve analiz için hayati önem taşır. Temel format string'i, yer tutucular (placeholders) içerir. Önceki örnekte kullanılan formatı biraz daha detaylandıralım:

# Spider init metodu içinde
formatter = logging.Formatter(
    '[%(asctime)s] - %(name)s - %(levelname)s - %(module)s.%(funcName)s:%(lineno)d - %(message)s',
    datefmt='%Y-%m-%d %H:%M:%S'
)
file_handler.setFormatter(formatter)

Bu format string'i birçok faydalı bilgi içerir:

• %(asctime)s: Loglandığı tarih ve saat.
• %(name)s: Logger'ın adı (yani spider'ın adı).
• %(levelname)s: Log mesajının seviyesi (INFO, DEBUG vb.).
• %(module)s: Log çağrısının yapıldığı modülün adı.
• %(funcName)s: Log çağrısının yapıldığı fonksiyonun adı.
• %(lineno)d: Log çağrısının yapıldığı satır numarası.
• %(message)s: Asıl log mesajı.

Bu gelişmiş format, bir hatanın tam olarak ne zaman, hangi spider'da, hangi dosyada ve hangi fonksiyonun hangi satırında meydana geldiğini size anında gösterir. Bu bilgiler, karmaşık hataların izini sürmek için paha biçilmezdir. Özellikle büyük Scrapy projelerinde, bir hatanın kökenini hızlıca bulmak, geliştirme süresini önemli ölçüde kısaltır.

Özelleştirilmiş log seviyeleri ve formatları kullanarak, Scrapy projelerinizin loglarını sadece bir kayıt yığını olmaktan çıkarıp, hata ayıklama ve performans izleme için etkili bir araca dönüştürebilirsiniz. Bir sonraki bölümde, log rotasyonu ve hata yakalama gibi daha ileri düzey konulara değineceğiz.

İleri Düzey Log Yönetimi: Log Rotasyonu, Hata Yakalama ve Performans İzleme

Temel dinamik loglama yapılandırmasını kurduktan sonra, Scrapy projelerinizin log yönetimini bir sonraki seviyeye taşımak için ileri düzey tekniklere bakmanın zamanı geldi. Bu teknikler, özellikle uzun süre çalışan veya çok fazla veri kazıyan projelerde log dosyalarının boyutunu kontrol altında tutmak, kritik hataları otomatik olarak bildirmek ve genel performansı izlemek için hayati öneme sahiptir.

Log Rotasyonu: Büyük Log Dosyalarına Son!

Her spider için ayrı log dosyaları tutmak harika, ancak zamanla bu dosyalar da devasa boyutlara ulaşabilir. Özellikle DEBUG seviyesinde loglama yapıyorsanız, birkaç saat içinde gigabaytlarca veri birikebilir. Bu, hem disk alanını tüketir hem de log dosyalarını açmayı ve analiz etmeyi zorlaştırır. Python'ın logging.handlers modülü, bu sorunu çözmek için RotatingFileHandler ve TimedRotatingFileHandler gibi güçlü araçlar sunar.

RotatingFileHandler: Boyuta Göre Rotasyon

Bu handler, log dosyasının belirli bir boyuta ulaştığında otomatik olarak yeni bir dosya oluşturmasını sağlar. Eski dosya yeniden adlandırılır (örn. .log.1, .log.2) ve belirli sayıda yedek kopya tutulur.

# Spider __init__ metodu içinde
from logging.handlers import RotatingFileHandler

# ... (önceki kod) ...

# 10 MB'a ulaşınca dosya rotasyonu yap, 5 tane yedek tut
file_handler = RotatingFileHandler(
    log_file_name,
    maxBytes=10 * 1024 * 1024, # 10 MB
    backupCount=5,
    encoding='utf-8'
)
file_handler.setLevel(logging.INFO)
file_handler.setFormatter(formatter)
self.logger.addHandler(file_handler)

Bu ayar ile my_spider.log dosyası 10 MB'a ulaştığında, adı my_spider.log.1 olarak değiştirilecek ve yeni loglar my_spider.log dosyasına yazılacaktır. Bu süreç backupCount değeri kadar tekrar eder.

TimedRotatingFileHandler: Zamana Göre Rotasyon

Eğer log dosyalarını günlük, haftalık veya saatlik periyotlarla rotasyona uğratmak isterseniz, TimedRotatingFileHandler daha uygundur. Bu, özellikle logları tarih bazında arşivlemek istediğinizde faydalıdır.

# Spider __init__ metodu içinde
from logging.handlers import TimedRotatingFileHandler

# ... (önceki kod) ...

# Her gece yarısı (midnight) rotasyon yap, son 7 günü sakla
file_handler = TimedRotatingFileHandler(
    log_file_name,
    when='midnight', # 'h' (saatlik), 'd' (günlük), 'w0' (Pazartesi), 's' (saniyelik) gibi seçenekler de var
    interval=1, # Her 'when' biriminde bir kez (örn. her gün)
    backupCount=7,
    encoding='utf-8'
)
file_handler.setLevel(logging.INFO)
file_handler.setFormatter(formatter)
self.logger.addHandler(file_handler)

Hata Yakalama ve Bildirim: Kritik Sorunları Anında Tespit Edin

Scrapy projelerinizde meydana gelen kritik hataları sadece log dosyasına yazmak yeterli değildir; bu hatalardan anında haberdar olmak istersiniz. Bunun için loglama sisteminizi harici servislerle entegre edebilirsiniz:

1. Sentry Entegrasyonu: Sentry, modern hata izleme platformlarından biridir. Scrapy projenize Sentry SDK'sını ekleyerek, ERROR veya CRITICAL seviyesindeki log mesajlarını otomatik olarak Sentry'ye gönderebilirsiniz. Sentry, bu hataları gruplar, bildirimler gönderir ve detaylı hata izleri sunar. Bu, özellikle üretim ortamında proaktif hata yönetimi için hayati öneme sahiptir.
2. E-posta veya Anlık Mesajlaşma (Slack/Telegram): Daha basit bir çözüm olarak, logging.handlers.SMTPHandler ile kritik hataları e-posta ile alabilir veya özel bir handler yazarak (veya mevcut kütüphaneleri kullanarak) Slack veya Telegram gibi platformlara bildirim gönderebilirsiniz. Bu sayede, herhangi bir kritik durum oluştuğunda anında haberdar olursunuz.

# settings.py (Sentry için)
# pip install sentry-sdk
import sentry_sdk
from sentry_sdk.integrations.logging import LoggingIntegration

sentry_sdk.init(
    dsn="YOUR_SENTRY_DSN_HERE",
    integrations=[LoggingIntegration(level=logging.ERROR)],
    traces_sample_rate=1.0,
)

Bu ayar ile Scrapy'den gelen tüm ERROR seviyesindeki veya daha yüksek log mesajları otomatik olarak Sentry'ye gönderilir.

Performans İzleme İçin Loglama

Loglama sadece hataları değil, aynı zamanda projenizin performansını da izlemek için kullanılabilir. Örneğin:

• İşlem Sürelerini Loglama: Bir sayfanın işlenmesinin ne kadar sürdüğünü veya bir isteğin ne kadar sürede tamamlandığını INFO seviyesinde loglayarak zaman içindeki performans trendlerini takip edebilirsiniz.
• Kaynak Kullanımını İzleme: Özel log mesajları ile belirli aralıklarla hafıza veya CPU kullanımını kaydederek darboğazları tespit edebilirsiniz.
• Spider İstatistikleri: Scrapy'nin kendi istatistik sistemine ek olarak, önemli metrikleri (kazınan ürün sayısı, başarısız istek sayısı) spider kapandığında loglayarak her spider'ın performansını özetleyebilirsiniz.

# Spider kapandığında istatistikleri loglama (signals.py veya spider içinde)
from scrapy import signals
from scrapy.crawler import CrawlerProcess

# Spider sınıfı içinde veya bir Scrapy Extension'da
class MySpider(Spider):
    # ...
    def closed(self, reason):
        self.logger.info(f'Spider {self.name} kapatıldı. Sebep: {reason}')
        self.logger.info(f'Kazınan ögeler: {self.crawler.stats.get_value("item_scraped_count", 0)}')
        self.logger.info(f'Başarısız istekler: {self.crawler.stats.get_value("downloader/response_status_count/404", 0)}')

Bu tür detaylı loglama, Scrapy projelerinizin uzun vadeli sağlığını ve verimliliğini korumak için vazgeçilmezdir. Log rotasyonu ile disk alanından tasarruf ederken, harici entegrasyonlarla proaktif hata yönetimi sağlayabilir ve performans izleme ile sürekli optimizasyon yapabilirsiniz. Bu yaklaşımlar, özellikle geniş ölçekli ve sürekli çalışan veri kazıma altyapılarında projenin istikrarını ve güvenilirliğini artırır.

Mobil Uyumlu HTML ve Log Görselleştirme İpuçları

Log dosyalarını dinamik olarak yönetmek harika bir başlangıç, ancak bu logları etkili bir şekilde okumak ve yorumlamak da önemlidir. Özellikle yöneticiler veya operasyon ekipleri, logları mobil cihazlar üzerinden hızlıca kontrol etmek isteyebilirler. Doğrudan ham log dosyalarını mobil cihazlarda okumak genellikle zordur. Bu nedenle, log verilerinin daha erişilebilir ve görsel olarak hoş bir şekilde sunulması için bazı yaklaşımlar önemlidir.

Log Görselleştirme Araçları ve Mobil Uyum

Scrapy'nin kendisi bir görselleştirme aracı sağlamaz, ancak toplanan log verilerini işleyip web tabanlı bir arayüze sunan üçüncü taraf araçlar veya özel geliştirilmiş panolar kullanabilirsiniz. Bu tür bir arayüz tasarlarken, mobil uyumluluk modern web geliştirmenin temel taşıdır.

1. Log Yönetimi Platformları: ELK Stack (Elasticsearch, Logstash, Kibana), Grafana, Splunk gibi platformlar, log verilerini merkezi olarak toplar, indeksler ve zengin görselleştirme panoları sunar. Bu panolar genellikle responsive tasarıma sahiptir, yani mobil cihazlardan da kolayca erişilebilir ve okunabilirler.
2. Özel Panolar (Dashboard'lar): Eğer kendi log görüntüleyicinizi geliştiriyorsanız, HTML ve CSS ile mobil uyumluluğu sağlamak kritik öneme sahiptir. Temel prensip, küçük ekranlarda öğelerin dikey olarak yığılması ve okunabilirlik için yazı tipi boyutlarının ayarlanmasıdır.

    
    
    
    


    

        

            2023-10-27 10:30:05
            INFO
            MySpider
        
        
URL http://quotes.toscrape.com/page/1/ başarıyla işlendi.
    

    

        

            2023-10-27 10:31:10
            WARNING
            BooksSpider
        
        
Erişilemeyen URL tespit edildi: http://example.com/broken-link (404 Not Found)
    

    

        

            2023-10-27 10:32:45
            ERROR
            ElectronicsSpider
        
        
Veritabanına kayıt sırasında hata oluştu: Unique constraint violation on product_id.
    

Yukarıdaki örnek HTML ve CSS yapısı, basit bir log görüntüsü için mobil uyumluluğun nasıl sağlanabileceğine dair bir fikir vermektedir. viewport meta etiketi, mobil tarayıcıların sayfayı cihaz genişliğine göre ölçeklendirmesini sağlar. @media (max-width: 768px) kuralı ise, ekran genişliği belirli bir eşiğin altına düştüğünde log başlıklarının (log-header) nasıl dikey olarak sıralanacağını gösterir. Bu, daha küçük ekranlarda okunabilirliği artırır.

Sonuç olarak, dinamik loglama ile üretilen değerli bilgilerin erişilebilirliğini artırmak için mobil uyumlu görselleştirme yaklaşımlarını düşünmek, Scrapy projelerinizin yönetimini daha da kolaylaştıracaktır. Bu, sadece geliştiriciler için değil, aynı zamanda operasyonel kararlar alan diğer ekip üyeleri için de kritik öneme sahiptir.

Sonuç: Dinamik Loglama ile Scrapy Projelerinizde Tam Kontrol

Bu makale boyunca, Scrapy projelerinizde her spider için dinamik olarak ayrı log dosyaları oluşturmanın ve bu logları etkili bir şekilde yönetmenin neden bu kadar önemli olduğunu detaylı bir şekilde inceledik. Gördüğümüz gibi, basit bir logging.FileHandler yapılandırmasından başlayarak, log rotasyonu, özel formatlayıcılar ve harici hata izleme sistemleriyle entegrasyon gibi ileri düzey tekniklere kadar geniş bir yelpazede çözümler mevcut. Bu yaklaşımlar, Scrapy projeleriniz büyüdükçe ortaya çıkan log karmaşasını ortadan kaldırır ve hata ayıklama, performans izleme ve genel proje yönetimi süreçlerini önemli ölçüde basitleştirir.

Dinamik loglama sayesinde, her spider kendi izole "günlüğünü" tutar. Bu, bir sorunla karşılaştığınızda, hangi spider'ın ne yaptığını, hangi aşamada olduğunu ve ne tür hatalarla karşılaştığını hızlıca tespit etmenizi sağlar. Bu proaktif yaklaşım, hem geliştirme süresini kısaltır hem de üretim ortamındaki olası kesintileri minimize eder. Ayrıca, log seviyelerini ve formatlarını özelleştirerek, ihtiyacınız olan doğru bilgi yoğunluğunu elde edersiniz, bu da log dosyalarınızı gereksiz bilgilerle doldurmaktan kaçınmanızı sağlar.

Unutmayın ki iyi bir loglama stratejisi, sadece hata ayıklama aracı olmaktan öte, projenizin sağlığını sürekli takip etmenizi sağlayan bir izleme sistemidir. Logları düzenli olarak gözden geçirmek, potansiyel sorunları büyümeden önce yakalamanıza, performans darboğazlarını tespit etmenize ve Scrapy spider'larınızın web siteleriyle nasıl etkileşime girdiğini anlamanıza yardımcı olur. Artık Scrapy projelerinizde log yönetimini tamamen kontrol altına almak için gerekli bilgi ve araçlara sahipsiniz. Başarılı kazımalar ve sorunsuz projeler dileriz!

Sıkça Sorulan Sorular (SSS)

1. Neden her spider için ayrı log dosyası kullanmalıyım?

Birden fazla spider aynı anda çalıştığında, tüm logların tek bir dosyada olması karmaşaya yol açar. Her spider için ayrı bir log dosyası, hangi spider'ın hata verdiğini, ne zaman ve hangi bağlamda olduğunu kolayca belirlemenizi sağlar, böylece hata ayıklama ve performans izleme süreçleri büyük ölçüde hızlanır.

2. Scrapy'nin varsayılan loglama davranışını nasıl değiştirebilirim?

settings.py dosyanızda LOG_FILE = None ayarlayarak Scrapy'nin tüm logları tek bir dosyaya yazmasını engelleyebilir ve LOG_LEVEL ile global log seviyesini kontrol edebilirsiniz. Ardından, her spider'ın __init__ metodunda kendi özel logger'ını ve dosya handler'ını yapılandırmanız gerekir.

3. Log dosyalarımın boyutunun çok büyümesini nasıl önleyebilirim?

Python'ın logging.handlers.RotatingFileHandler veya logging.handlers.TimedRotatingFileHandler sınıflarını kullanabilirsiniz. RotatingFileHandler, log dosyasının belirli bir boyuta ulaştığında rotasyon yapmasını sağlarken, TimedRotatingFileHandler belirli zaman aralıklarında (örn. günlük) rotasyon yapar ve belirli sayıda eski log dosyasını saklar.

4. Kritik hataları anında bildirim olarak nasıl alabilirim?

Python'ın logging modülünü Sentry gibi harici hata izleme platformları (sentry_sdk kütüphanesi ile) veya e-posta göndermek için logging.handlers.SMTPHandler ile entegre edebilirsiniz. Bu sayede, ERROR veya CRITICAL seviyesindeki log mesajları oluştuğunda anında haberdar olursunuz.

5. Scrapy'nin root logger'ına mesajların tekrar tekrar gönderilmesini nasıl engellerim?

Özel logger'ınızı oluşturduktan sonra self.logger.propagate = False olarak ayarlayarak, bu logger'dan gelen mesajların hiyerarşik olarak Scrapy'nin varsayılan (root) logger'ına yayılmasını engelleyebilirsiniz. Bu, loglarınızın tekrar etmesini önler ve daha temiz bir çıktı sağlar.