Loguru Python Günlükleme Eğitimi: Sıfır Yapılandırma ile Kurulum

Tüm kodlama hayatınız boyunca print() ifadeleriyle hata ayıklama yaptınız. Belki Python’un logging modülünü bir iki kez denediniz, ama daha basit olduğu için tekrar print’e döndünüz.

Aslında kullanımı en az onun kadar kolay, daha iyi bir seçenek var.

Print ifadeleri dosyalara kaydedilemez veya kolayca açılıp kapatılamaz. Python’un yerleşik logging’i bunları yapabilir, ancak programınızdan daha uzun kurulum kodu yazmanızı gerektirir.

Loguru farklı bir yaklaşım benimsiyor: günlükleme, yazdırma kadar kolay olmalı ama çok daha faydalı olmalı. Terminalinizde renkler, otomatik zaman damgaları ve tek satır bile yapılandırma yazmadan her şeyi dosyalara kaydetme özelliği elde edersiniz.

Bu eğitimde, günlüklemeyi zahmet değil doğal bir süreç gibi hissettiren pratik örnekler göstereceğim. Hata ayıklamayı gerçekten kolaylaştıran kod kalıplarını kullanarak muhtemelen varlığından haberdar olmadığınız özellikleri göreceksiniz.

Python hata ayıklamada yeniyseniz veya temel becerilerinizi güçlendirmek istiyorsanız, sağlam Python temelleri oluşturmak günlüklemenin ne zaman ve neden gerekli hale geldiğini anlamanıza yardımcı olur.

Loguru’ya Başlarken: Sıfır Yapılandırma Büyüsü

Loguru’yu kurmak tek bir komutla olur:

pip install loguru

Standart logging modülüyle, tek bir günlük mesajı görmeden önce işleyiciler (handler), biçimlendiriciler (formatter) kurup her şeyi yapılandırmanız gerekir. 

Python’un yerleşik günlükleme yaklaşımlarının daha derin bir karşılaştırması için, geleneksel yöntemleri kapsayan bu kapsamlı günlükleme eğitimine göz atın.

Loguru ile yalnızca içe aktarır ve günlüklemeye başlarsınız:

from loguru import logger

# Instead of print("Processing user data...")
logger.info("Processing user data...")

# Instead of print(f"Found {count} records")
logger.info("Found {} records", count)

Çıktı terminalinizde renkler, zaman damgaları ve günlük seviyeleriyle otomatik olarak görünür. Kurulum gerekmez.

Diyelim ki basit bir web kazıyıcı (scraper) oluşturuyorsunuz. Hata ayıklamanız şöyle değişir:

import requests
from loguru import logger

def scrape_website(url):
   logger.info("Starting scrape for {}", url)
  
   response = requests.get(url)
   logger.debug("Response status: {}", response.status_code)
  
   if response.status_code == 200:
       logger.success("Successfully scraped {} characters", len(response.text))
       return response.text
   else:
       logger.error("Failed to scrape {}: status {}", url, response.status_code)
       return None

Farklı günlük seviyelerine (info, debug, success, error) ve süslü parantezli biçimlendirmeye dikkat edin. Yapılandırma dosyaları veya kurulum kodu olmadan her şey anında çalışır.

Dosya Günlükleme ve Döndürme Basitleştirildi

Konsol çıktısıyla hata ayıklarken, terminali kapattığınız anda her şeyi kaybedersiniz. Bir saat önce ne olduğunu arayamazsınız ve betiğiniz gece çökerse, hatanın izine rastlayamazsınız. Yardım isterken hata ayıklama çıktınızı ekip arkadaşlarınızla da kolayca paylaşamazsınız.

Dosya günlükleme bunu her şeyi kalıcı olarak kaydederek çözer.

Geleneksel günlükleme, dosya işleyicilerini kurmak için yapılandırma kodu yazmanızı ister. Dosya yollarını belirtmeniz, dizinler oluşturmanız ve izinleri yönetmeniz gerekir. Loguru ile dosya günlükleme eklemek kelimenin tam anlamıyla tek satırdır:

from loguru import logger

# Add file logging alongside console output
logger.add("app.log")

logger.info("This appears in both console and file")
logger.error("So does this error message")

Artık her şey terminalinizde görünmeye devam ederken app.log dosyasına kaydedilir.

Ancak günlük dosyaları zamanla devasa boyutlara ulaşır. Günlerce çalışan bir web uygulaması, sonunda diskinizi dolduran gigabaytlarca günlük üretebilir. Dosya döndürme, belirli koşullar oluştuğunda otomatik olarak yeni günlük dosyaları oluşturarak bunu çözer. Eski dosya zaman damgasıyla yeniden adlandırılır ve yeni bir dosya başlatılır:

# When app.log reaches 10 MB, it becomes app_2024-07-15_14-30-25.log
# and a new empty app.log starts
logger.add("app.log", rotation="10 MB")

# Or start a new file every day at midnight
logger.add("app.log", rotation="00:00")

Varsayılan zaman damgaları işe yarar, ancak çoğunlukla UTC’dedir veya okumaları zordur. Loguru, tarih-saat biçimlerini ihtiyaçlarınıza göre özelleştirmenize olanak tanır:

# Custom timestamp format that's easier to read
logger.add("app.log",
         format="{time:YYYY-MM-DD HH:mm:ss} | {level} | {message}",
         rotation="1 day")

Üretim sistemlerinde, eski dosyalar üzerinde daha fazla denetime ihtiyacınız vardır. Üretim günlükleme, günlüklerinizin sürdürülebilir ve güvenli olmasını sağlamak için Python en iyi uygulamalarını takip etmeyi gerektirir. Yönetim olmadan, günlük dosyaları birikir ve depolamayı tüketir:

# Keep only the last 10 rotated files, compress the rest
logger.add("production.log",
         rotation="50 MB",     # New file every 50MB
         retention=10,         # Keep only 10 old files
         compression="zip")    # Compress rotated files

Bunu gerçekçi bir senaryoda görelim. Her gece birden fazla CSV dosyasını işleyen, müşteri verilerini veritabanınıza yüklemeden önce temizleyen ve doğrulayan bir veri hattı (pipeline) oluşturuyorsunuz. Hangi dosyaların başarıyla işlendiğini takip etmeli ve veri kalitesi sorunlarını yakalamalısınız:

import pandas as pd
from loguru import logger

# Production-ready file logging setup
logger.add("data_processing_{time:YYYY-MM-DD}.log",
         rotation="00:00",        # New file daily
         retention="1 week",      # Keep 1 week of logs
         format="{time:YYYY-MM-DD HH:mm:ss} | {level} | {message}")

def process_csv_files(file_list):
   logger.info("Starting batch processing of {} files", len(file_list))
  
   for filename in file_list:
       try:
           df = pd.read_csv(filename)
           logger.info("Loaded {} with {} rows", filename, len(df))
          
           # Your processing logic here
           processed_df = df.dropna()
          
           logger.success("Processed {} - kept {} rows", filename, len(processed_df))
          
       except Exception as e:
           logger.error("Failed to process {}: {}", filename, str(e))
  
   logger.info("Batch processing complete")

Günlükleriniz okunabilir zaman damgalarıyla kaydedilir, dosyalar otomatik olarak döndürülür ve eski günlükler kendi kendini temizler. Günler sonra ne olduğunu inceleyebilir veya sorun giderirken günlük dosyalarını çalışma arkadaşlarınıza gönderebilirsiniz.

Modern Uygulamalar için Yapısal Günlükleme

Bir web uygulaması çalıştırırken, günlükleriniz hızla karışık bilgi yığınına dönüşür. Kullanıcı eylemleri, veritabanı sorguları, API çağrıları ve hatalar bir metin duvarında birbirine karışır. Belirli kullanıcılar için filtreleme yapmak, tekil istekleri izlemek veya günlükleri izleme sistemleri için otomatik olarak ayrıştırmak kolay değildir.

Veri odaklı uygulamalar özellikle yapısal günlüklemeden fayda sağlar. Veri hatları veya analitikle çalışıyorsanız, veri analisti becerileri geliştirmek günlüklerinizde hangi bilgileri yakalamanız gerektiğini anlamanıza yardımcı olur.

Geleneksel metin tabanlı günlükleme bunu daha da kötüleştirir. Her günlük mesajı sadece metindir; anlamlı verileri çıkarmak karmaşık regex desenleri veya manuel arama gerektirir.

Yapısal günlükleme, günlük girdilerini yalnızca metin yerine veri nesneleri olarak ele alarak bunu değiştirir. Her günlük girdisi, aranabilir alanlara sahip yapısal bir kayda dönüşür; bu da programatik olarak sorgulayıp analiz etmeyi kolaylaştırır.

serialize=True ile JSON yapısal günlükleme

Loguru, serialize=True seçeneğiyle yapısal günlüklemeyi basitleştirir:

from loguru import logger

# Enable JSON structured logging
logger.add("api.log", serialize=True)

logger.info("User login", user_id=123, ip_address="192.168.1.1")
logger.error("Payment failed", user_id=123, amount=99.99, error_code="INSUFFICIENT_FUNDS")

serialize=True parametresi, Loguru’ya düz metin yerine JSON çıktı vermesini söyler. Okunabilir cümleler yerine, günlük dosyanız artık yapısal veri içerir:

{"text": "User login", "record": {"time": "2024-07-15T14:30:25", "level": {"name": "INFO"}, "extra": {"user_id": 123, "ip_address": "192.168.1.1"}}}

Bu format, JSON verilerini otomatik olarak arayıp filtreleyebilen günlük analiz araçlarıyla kusursuz çalışır.

Bağlam bağlama

Ancak web uygulamaları yalnızca yapısal veriden fazlasına ihtiyaç duyar. İlgili günlük girdilerini birbirine bağlayan bir bağlam gerekir. Bir kullanıcı isteğini işlerken, ilgili tüm günlüklerin kullanıcı kimliği veya oturum kimliği gibi ortak bilgileri paylaşmasını istersiniz.

Bağlam bağlama, logger.bind() kullanarak günlükleyicinize kalıcı bilgiler ekleyerek bunu çözer:

from loguru import logger

def process_user_order(user_id, order_data):
   # Create a logger with attached context
   order_logger = logger.bind(user_id=user_id, order_id=order_data['id'])
  
   order_logger.info("Starting order processing")
   order_logger.debug("Validating payment method", method=order_data['payment'])
   order_logger.info("Order processing complete", total=order_data['total'])

Artık order_logger üzerinden atılan her günlük, otomatik olarak user_id ve order_id içerir; bu da belirli bir siparişle ilgili tüm günlükleri izlemeyi kolaylaştırır.

Farklı çıktılar için çoklu alıcılar (sink)

Modern uygulamalar, farklı amaçlar için farklı günlük çıkışlarına da ihtiyaç duyar. Geliştirme sırasında okunabilir konsol günlükleri, üretimde ise izleme için JSON günlükleri isteyebilirsiniz. Loguru’da her çıktı hedefi bir “sink” olarak adlandırılır — günlük mesajlarının aktığı bir yer olarak düşünebilirsiniz.

Loguru, farklı format ve kurallarla birden çok alıcı eklemenize izin verir:

from loguru import logger
import sys

# Remove the default console output
logger.remove()

# Sink 1: Human-readable console for development
logger.add(sys.stdout,
         level="DEBUG",
         format="<green>{time:HH:mm:ss}</green> | {level} | {message}")

# Sink 2: JSON file for production monitoring
logger.add("app.log",
         serialize=True,
         level="INFO")

# Sink 3: Error-only file for alerts
logger.add("errors.log",
         level="ERROR")

logger.remove() çağrısı, kendi kurulumunuzu yapabilmeniz için Loguru’nun varsayılan konsol çıktısını kaldırır. Her logger.add(), neyin günlüklenip nasıl biçimlendirileceğine dair kendi kurallarına sahip yeni bir alıcı (sink) oluşturur.

Artık aynı günlük ifadeleri farklı çıktılar üretir:

logger.debug("Processing started")      # Only appears in console
logger.info("User data loaded")         # Appears in console and app.log
logger.error("Database connection failed")  # Appears in all three places

Tam Loguru örneği: Kullanıcı kayıt sistemi

Bunu Loguru kullanmanın daha basit ve gerçekçi bir örneğinde görelim — temel bir kullanıcı kayıt sistemi:

from loguru import logger
import sys

# Set up multiple outputs
logger.remove()
logger.add(sys.stdout, level="INFO", format="{time:HH:mm:ss} | {message}")
logger.add("user_registration.log", serialize=True, level="INFO")
logger.add("errors.log", level="ERROR")

def register_user(email, password):
   # Create logger with user context
   user_logger = logger.bind(email=email)
  
   user_logger.info("Starting user registration")
  
   # Validate email
   if "@" not in email:
       user_logger.error("Invalid email format")
       return False
  
   # Check if user exists
   user_logger.debug("Checking if user already exists")
  
   # Simulate password hashing
   user_logger.debug("Hashing password")
  
   # Save to database
   user_logger.info("Saving user to database")
   user_logger.success("User registration completed")
  
   return True

# Usage
register_user("john@example.com", "secure123")

Bu kurulum, geliştirme sırasında okunabilir konsol çıktısı, otomatik izleme için yapısal JSON günlükleri ve uyarılar için ayrı hata günlükleri sağlar. bind() yöntemi, her kullanıcı kaydı için tüm günlüklerin e-posta adresini içermesini sağlar; bu da hata ayıklamayı çok daha kolay hale getirir.

Loguru Özel Durum (Exception) Yönetimi

Kodunuz çöktüğünde genellikle hatanın nerede olduğunu söyleyen temel bir yığın izlemesi (stack trace) alırsınız, ancak nedenine dair pek bilgi yoktur. Çökme anındaki değişken değerlerini kaybedersiniz; bu da neyin yanlış gittiğini anlamayı zorlaştırır. Geleneksel özel durum yönetimi, her şeyi try-catch bloklarına sarmanızı ve her istisnayı elle günlüklemenizi de gerektirir.

Bu durum, üretim sorunlarını ayıklarken özellikle can sıkıcıdır. Kullanıcılar hataları bildirir, ancak hata meydana geldiğinde mevcut olan bağlama sahip olmadığınız için bunları yeniden üretemezsiniz.

Loguru, otomatik özel durum yakalama ve kodunuzda işler ters gittiğinde tam olarak neler olduğunu gösteren geliştirilmiş yığın izlemeleriyle bunu çözer.

@logger.catch ile otomatik özel durum yakalama

@logger.catch dekoratörü, bir fonksiyonda meydana gelen herhangi bir istisnayı otomatik olarak yakalar ve tam bağlamla günlükler. @logger.catch gibi dekoratörler, kod tabanınız genelinde hata yönetiminizi dönüştürebilecek orta seviye bir Python konseptidir:

from loguru import logger

@logger.catch
def divide_numbers(a, b):
   result = a / b
   return result

# This automatically logs the exception with full traceback
result = divide_numbers(10, 0)

Programınız temel bir hata mesajıyla çöküp kalmak yerine, Loguru istisnayı yakalar ve ayrıntılı bilgilerle günlüklerken programınız çalışmaya devam eder. Dekoratör, sınıf metodları, async fonksiyonlar veya normal fonksiyonlar dahil herhangi bir fonksiyonda çalışır.

Değişken incelemeli geliştirilmiş yığın izleri

Ancak Loguru, çağrı yığınının her seviyesinde değişken değerlerini gösteren geliştirilmiş yığın izleriyle daha da ileri gider. Bu özellik “diagnose” olarak adlandırılır ve sanki günlüklerinize gömülü bir hata ayıklayıcı varmış gibidir:

from loguru import logger

# Enable enhanced tracebacks
logger.add("debug.log", diagnose=True)

@logger.catch
def process_user_data(users):
   for user in users:
       age = user['age']
       if age > 0:
           years_to_retirement = 65 - age
           print(f"User {user['name']} has {years_to_retirement} years to retirement")

# When this crashes, you'll see the exact values of 'users', 'user', and 'age'
users_data = [
   {"name": "Alice", "age": 30},
   {"name": "Bob", "age": "invalid"},  # This will cause an error
]

process_user_data(users_data)

diagnose=True ile, fonksiyon bir sayıdan bir dize çıkarmaya çalışırken çöktüğünde, Loguru her değişkende ne olduğunu tam olarak gösterir:

TypeError: unsupported operand type(s) for -: 'int' and 'str'

Variables values:
   users = [{"name": "Alice", "age": 30}, {"name": "Bob", "age": "invalid"}]
   user = {"name": "Bob", "age": "invalid"}
   age = "invalid"

Bu ayrıntı düzeyi, soruna neden olan veriyi tam olarak görebildiğiniz için hata ayıklamayı çok daha hızlı hale getirir.

Ortam farkındalıklı özel durum yönetimi

Bununla birlikte, geliştirilmiş yığın izleri üretim günlüklerinde parolalar veya API anahtarları gibi hassas bilgileri açığa çıkarabilir. Loguru, bu davranışı farklı ortamlar için kontrol etmenize olanak tanır:

from loguru import logger
import os

# Development: Full diagnostic information
if os.getenv("ENVIRONMENT") == "development":
   logger.add("app.log", diagnose=True, level="DEBUG")
else:
   # Production: Basic logging without variable inspection
   logger.add("app.log", diagnose=False, level="INFO")

@logger.catch
def authenticate_user(username, password, api_key):
   # In development, you'll see all variable values if this crashes
   # In production, sensitive data stays hidden
   if not username or not password:
       raise ValueError("Missing credentials")

Performans için tembel değerlendirme (lazy evaluation)

Bir diğer güçlü özellik, maliyetli işlemlerden günlükleme yaparken performansı iyileştiren tembel değerlendirmedir. Bazen yalnızca gerçekten bir hata olursa karmaşık bilgileri günlüklemek istersiniz:

from loguru import logger

@logger.catch
def process_large_dataset(data):
   try:
       # Some complex processing that might fail
       result = complex_calculation(data)
       return result
   except Exception as e:
       # This expensive operation only runs if there's an error
       logger.error("Processing failed with data: {data}",
                   data=lambda: expensive_data_summary(data))
       raise

def expensive_data_summary(data):
   # This function takes time to run, summarizing huge datasets
   return {"row_count": len(data), "columns": list(data.keys()), "memory_usage": data.memory_usage()}

lambda: sözdizimi, Loguru gerçekten günlük mesajını yazdığında çağrılan bir fonksiyon oluşturur. Hata oluşmazsa, expensive_data_summary() hiç çalışmaz ve işlem süresi kazandırır.

Farklı hata türleri için farklı stratejiler

Farklı hata türleri için farklı özel durum yönetimi stratejileri de kullanabilirsiniz:

from loguru import logger

# Configure multiple outputs for different error severities
logger.add("warnings.log", level="WARNING", filter=lambda record: record["level"].name == "WARNING")
logger.add("critical_errors.log", level="ERROR")

@logger.catch(level="ERROR")
def critical_database_operation(query):
   # Database errors get logged as ERROR level
   execute_database_query(query)

@logger.catch(level="WARNING", reraise=False)
def optional_feature(user_id):
   # Non-critical features log as WARNING and continue execution
   send_optional_notification(user_id)

def process_user_request(user_id, query):
   # Critical operation - if this fails, the whole request fails
   critical_database_operation(query)
  
   # Optional operation - if this fails, request continues
   optional_feature(user_id)

reraise=False parametresi, Loguru’ya istisnayı günlüklemesini ancak tekrar yükseltmemesini söyler; böylece programınız çalışmaya devam eder. Bu, ana iş akışınızı bozmaması gereken isteğe bağlı özellikler için kullanışlıdır.

Tam örnek: hata yönetimiyle dosya işleme

Farklı türde hataları zarifçe ele alan bir dosya işleme sistemiyle tam bir örnek görelim:

from loguru import logger
import os

# Set up environment-aware logging
if os.getenv("DEBUG"):
   logger.add("file_processor.log", diagnose=True, level="DEBUG")
else:
   logger.add("file_processor.log", diagnose=False, level="INFO")

@logger.catch(reraise=False)
def validate_file_format(filename):
   if not filename.endswith(('.csv', '.json', '.xml')):
       raise ValueError(f"Unsupported file format: {filename}")

@logger.catch
def load_file_data(filename):
   logger.info("Loading file: {}", filename)
  
   # Expensive operation only logged on errors
   logger.debug("File stats: {stats}",
               stats=lambda: {"size": os.path.getsize(filename),
                             "modified": os.path.getmtime(filename)})
  
   with open(filename, 'r') as f:
       return f.read()

def process_files(file_list):
   results = []
  
   for filename in file_list:
       # Validation errors are logged but don't stop processing
       validate_file_format(filename)
      
       try:
           # Loading errors are logged and do stop processing this file
           data = load_file_data(filename)
           results.append(data)
           logger.success("Successfully processed {}", filename)
       except Exception:
           logger.error("Skipping file {} due to loading error", filename)
           continue
  
   return results

Bu kurulum, otomatik istisna yakalama, gerektiğinde ayrıntılı hata bağlamı ve farklı hata türleri için farklı yönetim stratejileri sunar. Günlükleriniz hata ayıklama için çok daha kullanışlı hale gelirken, kodunuz temiz ve okunabilir kalır.

İleri Düzey Loguru Yapılandırması ve Özelleştirme

Uygulamalarınız büyüdükçe, Loguru’nun varsayılanlarının tam olarak uymadığı senaryolarla karşılaşırsınız. Belki iş metrikleri için özel bir günlük seviyesi gerekir, günlüklerden hassas verileri filtrelemek istersiniz ya da hatalar olduğunda Slack’e uyarı göndermeniz gerekir.

İyi haber şu ki, Loguru basitliğini kaybetmeden özelleştirilebilir olacak şekilde tasarlanmıştır. Geleneksel günlükleme sistemlerinde karmaşık yapılandırma gerektirecek şekillerde genişletebilirsiniz; üstelik kodunuz temiz ve okunabilir kalır.

Üretim uygulamalarında karşılaşacağınız gerçek sorunları çözen en faydalı özelleştirmelere bakalım.

Özel günlük seviyeleri ve renkler

Loguru, INFO, DEBUG ve ERROR gibi standart seviyelerle gelir. Ancak bazen uygulamanıza özgü bir şeye ihtiyaç duyarsınız. Belki performans metrikleri veya iş olayları için özel bir seviye istersiniz.

Özel günlük seviyeleri oluşturmak oldukça basittir:

from loguru import logger

# Add a custom level for business metrics
logger.level("METRIC", no=38, color="<yellow>", icon="📊")

# Add a custom level for security events
logger.level("SECURITY", no=45, color="<red><bold>", icon="🔒")

# Now you can use these levels
logger.log("METRIC", "Order completed in {} seconds", 2.5)
logger.log("SECURITY", "Failed login attempt from IP: {}", "192.168.1.100")

no parametresi seviyenin önceliğini belirler (daha yüksek sayılar = daha yüksek öncelik). Standart seviyeler: DEBUG=10, INFO=20, WARNING=30, ERROR=40, CRITICAL=50.

Bunu bir makine öğrenimi eğitim senaryosunda görelim:

from loguru import logger

# Set up custom levels for ML tracking
logger.level("EPOCH", no=35, color="<cyan><bold>")
logger.level("CHECKPOINT", no=38, color="<green><bold>")

# Configure output
logger.remove()
logger.add("training_{time:YYYY-MM-DD}.log", level="INFO")

def train_model(model, data_loader, epochs=10):
   logger.info("Starting training with {} epochs", epochs)
  
   for epoch in range(epochs):
       # Log epoch progress with custom level
       logger.log("EPOCH", "Epoch {}/{} started", epoch + 1, epochs)
      
       # Training logic here
       loss = 0.523 - (epoch * 0.05)  # Simulated improving loss
       accuracy = 0.72 + (epoch * 0.03)  # Simulated improving accuracy
      
       logger.info("Loss: {:.4f}, Accuracy: {:.2%}", loss, accuracy)
      
       # Save checkpoint every 5 epochs
       if (epoch + 1) % 5 == 0:
           logger.log("CHECKPOINT", "Model saved at epoch {}", epoch + 1)
  
   logger.success("Training completed!")

Günlük mesajlarını yakalama ve değiştirme

Bazen, yazılmadan önce günlük mesajlarını değiştirmeniz gerekir. Yaygın kullanım alanları arasında hassas verileri kaldırma, istek kimlikleri ekleme veya belirli araçlara uygun biçimlendirme yer alır.

Loguru, filter parametresiyle mesajları yakalamanıza izin verir:

from loguru import logger
import re

def hide_sensitive_data(record):
   # Hide credit card numbers
   record["message"] = re.sub(r'\b\d{4}[\s-]?\d{4}[\s-]?\d{4}[\s-]?\d{4}\b',
                             'XXXX-XXXX-XXXX-XXXX',
                             record["message"])
  
   # Hide email addresses
   record["message"] = re.sub(r'\b[\w.-]+@[\w.-]+\.\w+\b',
                             '***@***.***',
                             record["message"])
  
   # Continue processing the log
   return True

# Add the filter to your logger
logger.add("secure.log", filter=hide_sensitive_data)

# Test it
logger.info("User paid with card 4532-1234-5678-9012")
logger.info("Contact email: john.doe@example.com")

Filtreleri bağlamsal bilgi eklemek için de kullanabilirsiniz:

from loguru import logger
import threading

def add_thread_info(record):
   # Add thread name to every log message
   record["extra"]["thread_name"] = threading.current_thread().name
   return True

def add_environment_info(record):
   # Add environment to production logs
   record["extra"]["env"] = "production"
   record["extra"]["region"] = "us-west-2"
   return True

# Apply multiple filters
logger.add(
   "app.log",
   filter=lambda record: add_thread_info(record) and add_environment_info(record),
   format="{time} | {extra[env]} | {extra[thread_name]} | {message}"
)

Dış servisler için özel alıcılar (custom sinks)

Alıcı (sink), günlüklerinizin aktığı yerdir. Dosyalar ve konsol yaygın olsa da, sık sık günlükleri Slack, e-posta veya izleme sistemleri gibi harici servislere göndermeniz gerekir.

İşte hataları Slack’e gönderen özel bir alıcı nasıl oluşturulur:

from loguru import logger
import requests

def send_to_slack(message):
   """Custom sink that sends messages to Slack"""
   # Parse the log record
   record = message.record
  
   # Only send errors and above
   if record["level"].no < 40:  # ERROR level is 40
       return
  
   # Format message for Slack
   slack_message = {
       "text": f"🚨 {record['level'].name}: {record['message']}",
       "attachments": [{
           "color": "danger",
           "fields": [
               {"title": "Time", "value": str(record["time"]), "short": True},
               {"title": "Function", "value": record["function"], "short": True},
               {"title": "File", "value": f"{record['file'].name}:{record['line']}", "short": False}
           ]
       }]
   }
  
   # Send to Slack webhook
   webhook_url = "https://hooks.slack.com/services/YOUR/WEBHOOK/URL"
   requests.post(webhook_url, json=slack_message)

# Add the custom sink
logger.add(send_to_slack, level="ERROR")

# Test it
logger.error("Database connection lost!")

Bir başka pratik örnek daha — uygulamanız çalışırken performans metriklerini toplayıp analiz için kaydeden özel bir alıcı:

from loguru import logger
from collections import defaultdict
import json

class MetricsCollector:
   def __init__(self):
       self.metrics = defaultdict(list)
  
   def __call__(self, message):
       """This method is called for every log message"""
       record = message.record
      
       # Only process METRIC level logs
       if record["level"].name != "METRIC":
           return
      
       # Extract metric data from the 'extra' fields
       extra = record["extra"]
       if "metric_name" in extra and "value" in extra:
           self.metrics[extra["metric_name"]].append({
               "value": extra["value"],
               "timestamp": record["time"].timestamp()
           })
  
   def save_metrics(self):
       """Save all collected metrics to a JSON file"""
       with open("metrics.json", "w") as f:
           json.dump(dict(self.metrics), f, indent=2)

# Create the collector and add it as a sink
collector = MetricsCollector()
logger.add(collector)

# Create the METRIC level
logger.level("METRIC", no=38)

# Now when you log metrics, they're automatically collected
# The bind() method attaches extra data to the log entry
logger.bind(metric_name="response_time", value=0.234).log("METRIC", "API response")
logger.bind(metric_name="response_time", value=0.189).log("METRIC", "API response")
logger.bind(metric_name="active_users", value=1523).log("METRIC", "User count")

# Later, save all metrics to file
collector.save_metrics()

# The metrics.json file will contain:
# {
#   "response_time": [
#     {"value": 0.234, "timestamp": 1627...},
#     {"value": 0.189, "timestamp": 1627...}
#   ],
#   "active_users": [
#     {"value": 1523, "timestamp": 1627...}
#   ]
# }

Bu yaklaşımın güzelliği, uygulama kodunuzun temiz kalmasıdır — metrikleri normal şekilde günlüklemeniz yeterlidir; toplayıcı alıcı depolamayı otomatik olarak halleder. Bunu, metrikleri Prometheus, DataDog veya başka herhangi bir izleme servisine gönderen bir alıcıyla kolayca değiştirebilirsiniz.

Bu özelleştirmeler, Loguru’yu basitliğini korurken özel ihtiyaçlarınıza uyarlama esnekliğini sunar. İster küçük bir betik, ister büyük bir uygulama oluşturuyor olun, Loguru’yu karmaşık yapılandırma dosyaları veya şablon kodu olmadan benzersiz günlükleme gereksinimlerinizi karşılayacak şekilde genişletebilirsiniz.

Sonuç

Loguru, Python’da günlüklemeyi olması gerektiği kadar basit hale getirir. Artık yapılandırma dosyaları, işleyici kurulumu veya şablon kod yok. Yalnızca içe aktarın ve renkler, zaman damgaları ve otomatik dosya döndürme ile günlüklemeye başlayın.

Yaygın acı noktalarını nasıl ele aldığını gördünüz: günlükleri dosyalara kaydetmek, otomatik olarak döndürmek, istisnaları tam bağlamla yakalamak ve günlükleri harici servislere göndermek. Yapısal günlükleme özellikleri onu üretime hazır kılarken, özel seviyeler ve alıcılar her kullanım durumuna uyarlamanıza olanak tanır.

Loguru’yu şu durumlarda kullanın:

• Print ile hata ayıklamaktan yorulduğunuzda
• Betiklerde veya not defterlerinde hızlı günlüklemeye ihtiyaç duyduğunuzda
• Yapısal günlüklemeye ihtiyaç duyan web uygulamaları geliştirirken
• Karmaşık kurulum olmadan daha iyi istisna takibi istediğinizde

Daha derin öğrenme için, bu resmi dokümantasyon ile birlikte kapsamlı Python günlükleme stratejileri için bu günlükleme eğitimini keşfedin.

Küçük başlayın. Bir print ifadesini logger.info() ile değiştirin. Geri dönmek istemeyeceksiniz.