Python Academy · Lekcja

Logowanie strukturalne

Proszę emitować logi w formacie JSON, aby były czytelne maszynowo.

Logowanie strukturalne to bezpłatna lekcja Python Academy na CoddyKit. To lekcja 3 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Python Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Python Academy zawiera 4 lekcji w sumie.

Czym jest logowanie strukturalne

Logowanie strukturalne emituje rekordy logów jako dane czytelne maszynowo (JSON), a nie jako tekst o dowolnym formacie, dzięki czemu można je łatwo indeksować, przeszukiwać i wykorzystywać do alertów.

import logging, json

def log_json(level, msg, **kw):
    record = {"level": level, "msg": msg, **kw}
    print(json.dumps(record))

log_json("INFO", "Request received", path="/api/users", method="GET")

Własny formatter JSON

Utwórz podklasę logging.Formatter, aby emitować JSON zamiast zwykłego tekstu.

import logging, json

class JSONFormatter(logging.Formatter):
    def format(self, record):
        return json.dumps({
            "time": self.formatTime(record),
            "level": record.levelname,
            "name": record.name,
            "msg": record.getMessage(),
        })

handler = logging.StreamHandler()
handler.setFormatter(JSONFormatter())
logging.getLogger().addHandler(handler)

python-json-logger

Pakiet python-json-logger udostępnia gotowy formatter JSON ze standardowymi i dodatkowymi polami.

# pip install python-json-logger
import logging
from pythonjsonlogger import jsonlogger

logger = logging.getLogger()
handler = logging.StreamHandler()
handler.setFormatter(jsonlogger.JsonFormatter())
logger.addHandler(handler)
logger.info("User created", extra={"user_id": 42})

structlog

structlog to popularna biblioteka zewnętrzna, która oddziela gromadzenie kontekstu od formatowania i obsługuje potoki procesorów.

# pip install structlog
import structlog

log = structlog.get_logger()
log = log.bind(request_id="abc123")
log.info("payment_processed", amount=49.99, currency="USD")

Powiązywanie kontekstu za pomocą structlog

structlog umożliwia powiązanie par klucz–wartość z loggerem, które są przekazywane do wszystkich kolejnych wywołań.

import structlog

log = structlog.get_logger().bind(
    service="auth",
    env="prod"
)
log.warning("login_failed", user="alice", reason="bad_password")
# {service:auth, env:prod, user:alice, reason:bad_password}

Dodawanie znaczników czasu i informacji o wywołującym

Procesory mogą automatycznie wzbogacać rekordy. Dodaj TimeStamper i CallsiteParameterAdder do każdego rekordu logu.

import structlog

structlog.configure(
    processors=[
        structlog.processors.TimeStamper(fmt="iso"),
        structlog.processors.CallsiteParameterAdder([structlog.processors.CallsiteParameter.FILENAME]),
        structlog.processors.JSONRenderer(),
    ]
)

Logowanie identyfikatorów żądań w aplikacjach internetowych

W frameworku internetowym powiąż identyfikator żądania na początku każdego żądania, aby każdy wiersz logu podczas tego żądania go zawierał.

import structlog

def middleware(request, call_next):
    req_id = request.headers.get("X-Request-Id", generate_id())
    log = structlog.get_logger().bind(request_id=req_id)
    log.info("request_started", path=request.url.path)
    response = call_next(request)
    log.info("request_finished", status=response.status_code)
    return response

Format logów ECS

Elastic Common Schema (ECS) to standardowy format logów JSON używany przez Elastic Stack. W Pythonie użyj ecs-logging.

# pip install ecs-logging
import logging
import ecs_logging

logger = logging.getLogger("app")
handler = logging.StreamHandler()
handler.setFormatter(ecs_logging.StdlibFormatter())
logger.addHandler(handler)
logger.info("Event logged in ECS format")

Systemy agregacji logów

Ustrukturyzowane logi JSON naturalnie trafiają do narzędzi agregujących: Elasticsearch/Kibana (ELK), Grafana Loki, Datadog, AWS CloudWatch Logs Insights.

# Loki query example:
# {app="myservice"} | json | level="ERROR"

# CloudWatch Insights:
# fields @timestamp, level, msg
# | filter level = "ERROR"
# | sort @timestamp desc

Unikanie danych osobowych w logach

Usuń dane umożliwiające identyfikację osoby przed zapisaniem ich w logach. Użyj własnego procesora lub filtra, aby zamaskować adresy e-mail, tokeny i hasła.

import re

def mask_pii(_, __, event_dict):
    msg = event_dict.get("event", "")
    event_dict["event"] = re.sub(
        r"[\w.+-]+@[\w-]+\.[\w.]+", "***@***.***", msg
    )
    return event_dict

Kompromisy między logami strukturalnymi i niestrukturalnymi

Logi strukturalne można przeszukiwać i wykorzystywać do alertów, ale są rozwlekłe. W środowisku produkcyjnym połącz logowanie strukturalne z formatowaniem czytelnym dla człowieka w środowisku programistycznym, używając konfiguracji zależnej od środowiska.

import structlog, os

if os.getenv("ENV") == "production":
    renderer = structlog.processors.JSONRenderer()
else:
    renderer = structlog.dev.ConsoleRenderer()

structlog.configure(processors=[renderer])

Szybkie sprawdzenie

Jaka jest główna zaleta logów w formacie JSON względem logów w zwykłym tekście?

Podsumowanie

Logowanie strukturalne emituje rekordy JSON w postaci klucz–wartość. Używaj JSONFormatter, python-json-logger lub structlog. Powiąż kontekst (identyfikator żądania, użytkownik) na początku operacji, aby każdy wiersz logu podczas tej operacji zawierał ten kontekst.

Często zadawane pytania

Czy lekcja „Logowanie strukturalne” jest bezpłatna?

Tak — pełny tekst „Logowanie strukturalne” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Python Academy, przejdź na CoddyKit PRO. Kurs Python Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Logowanie strukturalne”?

Proszę emitować logi w formacie JSON, aby były czytelne maszynowo. Ćwiczysz Python Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Python Academy?

Nie wymagamy żadnego doświadczenia. Python Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 4.

Ile czasu zajmuje lekcja „Logowanie strukturalne”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Python Academy?

Tak. Każda lekcja Python Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do Python Academy