0Pricing
AI Agents · Lekcja

Logowanie śledzenia kroków agenta

Rejestrowanie każdego kroku rozumowania, wywołania narzędzia i wyniku na potrzeby analizy po awarii.

Logowanie śledzenia kroków agenta to bezpłatna lekcja AI Agents na CoddyKit. To lekcja 2 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 AI Agents, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs AI Agents zawiera 4 lekcji w sumie.

Dlaczego logowanie śladów jest niezbędne w przypadku agentów

Standardowe logi aplikacji rejestrują błędy i zdarzenia. Logi śledzenia agenta rejestrują rozumowanie: co agent uznał na każdym kroku, jakie narzędzie wybrał, jakich argumentów użył i co zwróciło narzędzie?

Bez logowania śladów debugowanie awarii agenta przypomina diagnozowanie problemu z samochodem bez deski rozdzielczej — można tylko zgadywać.

Konfigurowanie modułu logging w Pythonie

Wbudowany w Pythona moduł logging jest standardowym narzędziem. Należy skonfigurować go na początku działania agenta, używając formatu zawierającego znacznik czasu, poziom i komunikat. Do danych śledzenia należy użyć poziomu DEBUG — można go wyłączyć w środowisku produkcyjnym.

import logging
import sys

logging.basicConfig(
    level=logging.DEBUG,
    format='%(asctime)s [%(levelname)s] %(name)s: %(message)s',
    datefmt='%H:%M:%S',
    stream=sys.stdout
)

logger = logging.getLogger('myagent')

# Usage:
logger.debug('Step 1: reasoning started')
logger.info('Agent task completed in 5 steps')
logger.warning('Tool returned empty result')
logger.error('Failed to parse tool arguments')

# Output:
# 14:32:01 [DEBUG] myagent: Step 1: reasoning started
# 14:32:03 [INFO] myagent: Agent task completed in 5 steps

Rejestrowanie każdego kroku rozumowania

Na początku każdego kroku należy rejestrować najważniejsze informacje: numer kroku, rozumowanie wygenerowane przez LLM, wybrane narzędzie i przekazane do niego argumenty. W ten sposób powstaje kompletny zapis procesu decyzyjnego agenta.

import logging
import json

logger = logging.getLogger('myagent')

def log_step(step: int, thought: str, tool_name: str, tool_args: dict):
    logger.debug(
        f'Step {step}: '
        f'reasoning="{thought[:100]}" '
        f'tool={tool_name} '
        f'args={json.dumps(tool_args, ensure_ascii=False)[:200]}'
    )

# Example usage in the agent loop:
# log_step(
#     step=1,
#     thought='I need to find the current weather in Tokyo',
#     tool_name='get_weather',
#     tool_args={'city': 'Tokyo', 'unit': 'celsius'}
# )

if __name__ == '__main__':
    import sys
    logging.basicConfig(level=logging.DEBUG, format='%(message)s', stream=sys.stdout)
    log_step(
        step=1,
        thought='I need to find the current weather in Tokyo',
        tool_name='get_weather',
        tool_args={'city': 'Tokyo', 'unit': 'celsius'}
    )

Rejestrowanie wyników narzędzi

Po każdym wywołaniu narzędzia należy rejestrować informację o tym, czy zakończyło się ono powodzeniem, oraz podgląd wyniku. Rejestrowanie pełnego wyniku może być zbyt szczegółowe — dla czytelności należy ograniczyć podgląd do pierwszych 200 znaków.

import logging

logger = logging.getLogger('myagent')

def log_tool_result(step: int, tool_name: str, result: str, success: bool):
    status = 'OK' if success else 'ERROR'
    preview = str(result)[:200].replace('\n', ' ')
    logger.debug(
        f'Step {step} result [{status}]: tool={tool_name} '
        f'result_preview="{preview}"'
    )

    if not success:
        logger.warning(f'Tool {tool_name} failed at step {step}')

# Log at the start of the step:
# log_step(step, thought, tool_name, tool_args)
# result = execute_tool(tool_name, tool_args)
# log_tool_result(step, tool_name, result, success=True)

if __name__ == '__main__':
    import sys
    logging.basicConfig(level=logging.DEBUG, format='%(message)s', stream=sys.stdout)
    log_tool_result(1, 'get_weather', '{"temp_c": 18, "condition": "cloudy"}', success=True)
    log_tool_result(2, 'get_weather', 'Connection timed out', success=False)

Logowanie strukturalne w formacie JSON

Logi w postaci zwykłego tekstu są łatwe do odczytania, ale trudne do przeszukiwania. Ustrukturyzowane logi JSON można przesyłać do systemów agregowania logów (Datadog, Splunk, CloudWatch), aby filtrować dane oraz tworzyć pulpity i alerty.

import logging
import json
import sys

class JSONFormatter(logging.Formatter):
    def format(self, record: logging.LogRecord) -> str:
        log_obj = {
            'timestamp': self.formatTime(record),
            'level': record.levelname,
            'logger': record.name,
            'message': record.getMessage()
        }
        # Add any extra fields attached to the log record
        if hasattr(record, 'step'):
            log_obj['step'] = record.step
        if hasattr(record, 'tool'):
            log_obj['tool'] = record.tool
        return json.dumps(log_obj)

handler = logging.StreamHandler(sys.stdout)
handler.setFormatter(JSONFormatter())
logger = logging.getLogger('agent_trace')
logger.addHandler(handler)
logger.setLevel(logging.DEBUG)

logger.setLevel(logging.DEBUG)
logger.debug('Step 3: tool=search_web', extra={'step': 3, 'tool': 'search_web'})

Logowanie z dodatkowymi polami

Przekazanie extra={} do wywołania logowania pozwala dołączyć ustrukturyzowane pola, których formatery JSON lub systemy agregowania logów mogą używać do filtrowania i analizy.

import logging

logger = logging.getLogger('agent_trace')

def log_step_structured(step: int, tool: str, thought: str, args: dict):
    logger.debug(
        f'Step {step}: tool={tool}',
        extra={
            'step': step,
            'tool': tool,
            'thought': thought[:200],
            'tool_args': args
        }
    )

# If using a JSON formatter, this produces:
# {
#   'timestamp': '14:32:01',
#   'level': 'DEBUG',
#   'message': 'Step 3: tool=search_web',
#   'step': 3,
#   'tool': 'search_web',
#   'thought': 'I need to find recent news about...',
#   'args': {'query': 'AI news 2025'}
# }

if __name__ == '__main__':
    import sys
    handler = logging.StreamHandler(sys.stdout)
    handler.setFormatter(logging.Formatter('%(message)s | step=%(step)s tool=%(tool)s'))
    logger.addHandler(handler)
    logger.setLevel(logging.DEBUG)
    log_step_structured(3, 'search_web', 'I need to find recent news about...', {'query': 'AI news 2025'})

Logowanie do pliku

W przypadku agentów działających w środowisku produkcyjnym należy logować dane do pliku na potrzeby późniejszej analizy. Należy użyć RotatingFileHandler, aby ograniczyć rozmiar pliku logu i zapobiec wyczerpaniu miejsca na dysku.

import logging
from logging.handlers import RotatingFileHandler
import sys

logger = logging.getLogger('myagent')
logger.setLevel(logging.DEBUG)

# Console handler — INFO and above
console = logging.StreamHandler(sys.stdout)
console.setLevel(logging.INFO)
console.setFormatter(logging.Formatter('%(message)s'))

# File handler — DEBUG and above, rotates at 10MB
file_handler = RotatingFileHandler(
    'agent_trace.log',
    maxBytes=10 * 1024 * 1024,  # 10 MB
    backupCount=3
)
file_handler.setLevel(logging.DEBUG)
file_handler.setFormatter(logging.Formatter(
    '%(asctime)s [%(levelname)s] %(message)s'
))

logger.addHandler(console)
logger.addHandler(file_handler)

logger.info('Agent task completed in 5 steps')
logger.debug('Step 1: reasoning started')

Logowanie identyfikatorów sesji w agentach wieloużytkownikowych

Gdy jednocześnie działa wielu użytkowników lub wykonywanych jest wiele zadań, logi mogą się przeplatać. Do każdego komunikatu logu należy dołączyć identyfikator sesji lub zadania, aby można było filtrować logi dotyczące konkretnego uruchomienia.

import logging
import uuid

class SessionLogger:
    def __init__(self, name: str):
        self.logger = logging.getLogger(name)
        self.session_id = str(uuid.uuid4())[:8]

    def debug(self, msg: str, **kwargs):
        self.logger.debug(f'[session={self.session_id}] {msg}', **kwargs)

    def info(self, msg: str, **kwargs):
        self.logger.info(f'[session={self.session_id}] {msg}', **kwargs)

    def error(self, msg: str, **kwargs):
        self.logger.error(f'[session={self.session_id}] {msg}', **kwargs)

# Each agent run gets its own logger with a unique session ID
# log = SessionLogger('myagent')
# log.info(f'Starting task: {query}')  # [session=a3f1b290] Starting task: ...

if __name__ == '__main__':
    import sys
    logging.basicConfig(level=logging.INFO, format='%(message)s', stream=sys.stdout)
    log = SessionLogger('myagent')
    log.info(f'Starting task: summarize the quarterly report')

Pomiar czasu każdego kroku

Do logu każdego kroku należy dodać informacje o czasie, aby identyfikować wąskie gardła. Które narzędzie działa najwolniej? Ile czasu LLM potrzebuje na rozumowanie? Te dane pomagają kierować optymalizacją.

import time
import logging

logger = logging.getLogger('myagent')

def timed_tool_call(tool_name: str, tool_fn, args: dict) -> str:
    start = time.perf_counter()
    try:
        result = tool_fn(**args)
        elapsed = time.perf_counter() - start
        logger.debug(f'Tool {tool_name} completed in {elapsed:.2f}s')
        return result
    except Exception as e:
        elapsed = time.perf_counter() - start
        logger.error(f'Tool {tool_name} failed in {elapsed:.2f}s: {e}')
        raise

# In the agent loop:
# result = timed_tool_call('search_web', search_web, {'query': 'Python'})
# Logs: Tool search_web completed in 1.34s

if __name__ == '__main__':
    import sys
    logging.basicConfig(level=logging.DEBUG, format='%(message)s', stream=sys.stdout)
    def search_web(query):
        return f'3 results for {query}'
    result = timed_tool_call('search_web', search_web, {'query': 'Python'})
    print('Tool result:', result)

Kompletny wzorzec śledzenia kroków

Oto kompletny, gotowy do użycia w środowisku produkcyjnym wzorzec logowania śladów kroku agenta. Każdy krok rejestruje swój numer, rozumowanie, wybór narzędzia, argumenty, podgląd wyniku i czas wykonania — zapewniając pełny wgląd w działanie agenta.

import time
import logging
import json

logger = logging.getLogger('myagent')

def trace_step(step_num: int, thought: str, tool: str, args: dict, execute_fn):
    # Log decision
    logger.debug(
        f'Step {step_num}: thought="{thought[:80]}" tool={tool} '
        f'args={json.dumps(args)[:100]}'
    )

    # Execute with timing
    t0 = time.perf_counter()
    try:
        result = execute_fn(tool, args)
        elapsed = time.perf_counter() - t0
        preview = str(result)[:100].replace('\n', ' ')
        logger.debug(f'Step {step_num} done in {elapsed:.2f}s: "{preview}"')
        return result
    except Exception as e:
        elapsed = time.perf_counter() - t0
        logger.error(f'Step {step_num} failed in {elapsed:.2f}s: {e}')
        return f'ERROR: {e}'

if __name__ == '__main__':
    import sys
    logging.basicConfig(level=logging.DEBUG, format='%(message)s', stream=sys.stdout)
    def execute_fn(tool, args):
        return f'42 (from {tool})'
    trace_step(1, 'I should compute the answer', 'calculator', {'expr': '6*7'}, execute_fn)

Wyłączanie logów w środowisku produkcyjnym

Logi śledzenia na poziomie debugowania zawierają poufne dane (zapytania, odpowiedzi API) i mogą być bardzo szczegółowe. W środowisku produkcyjnym należy ustawić poziom logowania na INFO lub WARNING, aby ukryć ślady debugowania. Do sterowania poziomem należy użyć zmiennej środowiskowej.

import os
import logging
import sys

# Read log level from environment variable
log_level_str = os.environ.get('LOG_LEVEL', 'INFO').upper()
log_level = getattr(logging, log_level_str, logging.INFO)

logging.basicConfig(level=log_level, stream=sys.stdout)
logger = logging.getLogger('myagent')

# Development: LOG_LEVEL=DEBUG python agent.py     -> full traces
# Production:  LOG_LEVEL=WARNING python agent.py  -> only warnings/errors
# Default:     LOG_LEVEL not set                  -> INFO level

logger.debug('This only appears in DEBUG mode')
logger.info('This appears in INFO and DEBUG modes')
logger.warning('This always appears')

Sprawdzenie wiedzy: logowanie śladów

Sprawdź swoje rozumienie logowania śladów kroków agenta.

Podsumowanie: logowanie śladów kroków agenta

Mają Państwo teraz kompletną strategię logowania śladów agentów:

  • Użyć logging.basicConfig(level=DEBUG), aby włączyć logi na poziomie śledzenia
  • Na każdym kroku rejestrować numer kroku, rozumowanie, nazwę narzędzia i argumenty
  • Rejestrować wyniki narzędzi wraz z podglądem oraz statusem powodzenia lub niepowodzenia
  • Używać formatowania JSON do tworzenia ustrukturyzowanych logów, które można przeszukiwać
  • Dołączać identyfikatory sesji w przypadku agentów wieloużytkownikowych lub współbieżnych
  • Dodawać informacje o czasie, aby identyfikować powolne kroki
  • Sterować szczegółowością logów za pomocą zmiennej środowiskowej LOG_LEVEL

Często zadawane pytania

Czy lekcja „Logowanie śledzenia kroków agenta” jest bezpłatna?

Tak — pełny tekst „Logowanie śledzenia kroków agenta” 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 AI Agents, przejdź na CoddyKit PRO. Kurs AI Agents zawiera 4 lekcji w sumie.

Co nauczysz się w „Logowanie śledzenia kroków agenta”?

Rejestrowanie każdego kroku rozumowania, wywołania narzędzia i wyniku na potrzeby analizy po awarii. Ćwiczysz AI Agents 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ąć AI Agents?

Nie wymagamy żadnego doświadczenia. AI Agents 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 2 z 4.

Ile czasu zajmuje lekcja „Logowanie śledzenia kroków agenta”?

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 AI Agents?

Tak. Każda lekcja AI Agents 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

  1. Typowe awarie pętli agenta
  2. Logowanie śledzenia kroków agenta
  3. Wykrywanie i przerywanie nieskończonych pętli
  4. Techniki debugowania krok po kroku
← Powrót do AI Agents