Anbefalte metoder for strukturert logging
Implementer strukturert logging for enklere tolking og analyse samt raskere feilsøking av problemer i produksjon
Anbefalte metoder for strukturert logging er en gratis leksjon i Håndbok for feilsøking i produksjon og hendelseshåndtering på CoddyKit. Dette er leksjon 1 av 4. Du kan lese valgfritt 3 leksjoner fra denne læringsstien gratis i sin helhet – deretter låser CoddyKit PRO opp alle leksjoner, samt praktisk øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Håndbok for feilsøking i produksjon og hendelseshåndtering, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Håndbok for feilsøking i produksjon og hendelseshåndtering inneholder totalt 4 leksjoner.
Hva er logger?
Logger er registreringer av hendelser som skjer i applikasjonen eller systemet. Tenk på dem som en dagbok for programvaren!
De er avgjørende for å forstå hva programmet gjør, spesielt når noe går galt i et aktivt «produksjonsmiljø».
Den rotete virkeligheten
Ofte er logger bare vanlige tekststrenger. Dette kalles ustrukturert logging. Selv om ustrukturerte logger er enkle å skrive, er de vanskelige for datamaskiner å lese og analysere, noe som gjør feilsøking til en langsom, manuell prosess.
Se på dette eksempelet:
import logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
def process_order(order_id, item_count):
logger.info(f"Processing order {order_id} with {item_count} items.")
if item_count > 10:
logger.warning(f"Large order detected for {order_id}. Items: {item_count}.")
logger.info(f"Order {order_id} processed successfully.")
if __name__ == "__main__":
process_order("ORD-123", 5)
process_order("ORD-456", 12)Hva er strukturert logging?
Strukturert logging betyr at loggene er formatert som maskinlesbare data, ikke bare som fri tekst. Det vanligste formatet er JSON.
I stedet for én enkelt streng er hver loggoppføring et objekt med nøkkel-verdi-par. Dette gjør dem enkle å søke i, filtrere og analysere programmatisk.
Derfor er strukturert logging fantastisk
Strukturerte logger har mange fordeler:
- Raskere feilsøking: Finne relevante hendelser raskt.
- Bedre analyse: Enkelt spørre etter og aggregere data.
- Automatiserte verktøy: Integrere med systemer for overvåking og varsling.
- Ensartethet: Sikre at alle logger inneholder forventede felt.
JSON er kongen
Selv om det finnes andre formater, er JSON (JavaScript Object Notation) det mest populære valget for strukturert logging på grunn av enkelheten og den brede støtten.
En JSON-loggoppføring er et selvstendig objekt, noe som gjør formatet svært fleksibelt for lagring av varierte data. Slik kan en strukturert logg se ut:
{
"timestamp": "2023-10-27T10:30:00Z",
"level": "INFO",
"service": "order-processor",
"message": "Order processed successfully",
"order_id": "ORD-123",
"item_count": 5
}Skriv kode!
La oss se hvordan strukturert logging kan implementeres. Mange språk har biblioteker som gjør dette enkelt. Her er et grunnleggende Python-eksempel som bruker standardmodulen logging med en egendefinert JSON-formaterer.
import logging
import json
class JsonFormatter(logging.Formatter):
def format(self, record):
log_entry = {
"timestamp": self.formatTime(record, self.datefmt),
"level": record.levelname,
"name": record.name,
"message": record.getMessage(),
"file": record.filename,
"line": record.lineno
}
if hasattr(record, 'order_id'):
log_entry['order_id'] = record.order_id
if hasattr(record, 'item_count'):
log_entry['item_count'] = record.item_count
return json.dumps(log_entry)
logger = logging.getLogger(__name__)
logger.setLevel(logging.INFO)
handler = logging.StreamHandler()
handler.setFormatter(JsonFormatter())
logger.addHandler(handler)
def process_order(order_id, item_count):
extra_data = {'order_id': order_id, 'item_count': item_count}
logger.info("Processing order", extra=extra_data)
if item_count > 10:
logger.warning("Large order detected", extra=extra_data)
logger.info("Order processed successfully", extra=extra_data)
if __name__ == "__main__":
process_order("ORD-123", 5)
process_order("ORD-456", 12)Felt du må ha
Hver strukturerte loggoppføring bør inneholde disse kjernefeltene for effektiv analyse:
timestamp: Når hendelsen skjedde (ISO 8601-format).level: Alvorlighetsgrad (INFO, WARN, ERROR, DEBUG).service: Hvilken tjeneste eller applikasjon som genererte loggen.message: Et menneskelesbart sammendrag av hendelsen.hostname/pod_name: Hvor loggen oppstod.
Berik loggene dine
I tillegg til de nødvendige feltene bør De legge til kontekstdata som er spesifikke for hendelsen. Dette er viktig for å spore forespørsler på tvers av distribuerte systemer og hjelper Dem med å se sammenhenger ved feilsøking av komplekse problemer.
request_id: For å spore én enkelt brukerforespørsel.user_id: For å identifisere den involverte brukeren.transaction_id: For bestemte forretningstransaksjoner.
import logging
import json
import uuid
# Reusing the JsonFormatter from previous scene
class JsonFormatter(logging.Formatter):
def format(self, record):
log_entry = {
"timestamp": self.formatTime(record, self.datefmt),
"level": record.levelname,
"message": record.getMessage()
}
for key, value in record.__dict__.items():
if not key.startswith('_') and key not in ['name', 'levelname', 'pathname', 'filename', 'module', 'exc_info', 'exc_text', 'stack_info', 'lineno', 'funcName', 'created', 'msecs', 'relativeCreated', 'thread', 'threadName', 'processName', 'process', 'args', 'msg', 'asctime']:
log_entry[key] = value
return json.dumps(log_entry)
logger = logging.getLogger(__name__)
logger.setLevel(logging.INFO)
handler = logging.StreamHandler()
handler.setFormatter(JsonFormatter())
logger.addHandler(handler)
def handle_web_request(user_id):
request_id = str(uuid.uuid4())[:8]
extra_data = {'request_id': request_id, 'user_id': user_id, 'service': 'api-gateway'}
logger.info("Received web request", extra=extra_data)
if user_id == "user-vip":
logger.info("VIP user request detected", extra=extra_data)
else:
logger.debug("Standard user request", extra=extra_data)
logger.info("Request processed", extra=extra_data)
if __name__ == "__main__":
handle_web_request("user-123")
handle_web_request("user-vip")Loggnivåer
Loggnivåer bidrar til å kategorisere alvorlighetsgraden og viktigheten til en loggmelding. Vanlige nivåer inkluderer:
- DEBUG: Detaljert informasjon som bare er nyttig ved feilsøking.
- INFO: Bekreftelse på at ting fungerer som forventet.
- WARN: En uventet hendelse, men applikasjonen kjører fortsatt.
- ERROR: En feil som hindrer noe funksjonalitet i å fungere.
- CRITICAL: En alvorlig feil som kan gjøre at applikasjonen ikke kan fortsette.
Hurtigsjekk
Strukturert logging er en kraftig teknikk for å forbedre observability. La oss teste hvor godt De forstår de viktigste fordelene.
Oppsummering: Strukturert logging
De har lært om kraften i strukturert logging! Ved å formatere logger som maskinlesbare data (for eksempel JSON) får De raskere feilsøking, bedre analyse og sømløs integrasjon med overvåkingsverktøy.
Husk å ta med viktige felt og kontekstdata for å gjøre loggene virkelig nyttige ved diagnostisering av problemer i produksjon.
Lær deg Håndbok for feilsøking i produksjon og hendelseshåndtering med en AI-veileder – gratis
Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.
- Kurs
- 12
- Leksjoner
- 48
Ofte stilte spørsmål
Er leksjonen «Anbefalte metoder for strukturert logging» gratis?
Ja – du kan lese valgfritt 3 av leksjonene i læringsstien Håndbok for feilsøking i produksjon og hendelseshåndtering, inkludert «Anbefalte metoder for strukturert logging», gratis i sin helhet her på nettet. Deretter låser CoddyKit PRO opp alle leksjoner, samt interaktiv øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Kurset i Håndbok for feilsøking i produksjon og hendelseshåndtering inneholder totalt 4 leksjoner.
Hva lærer jeg i «Anbefalte metoder for strukturert logging»?
Implementer strukturert logging for enklere tolking og analyse samt raskere feilsøking av problemer i produksjon Du øver på Håndbok for feilsøking i produksjon og hendelseshåndtering med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.
Trenger jeg erfaring for å begynne med Håndbok for feilsøking i produksjon og hendelseshåndtering?
Ingen tidligere erfaring er nødvendig. Håndbok for feilsøking i produksjon og hendelseshåndtering på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 1 av 4.
Hvor lang tid tar leksjonen «Anbefalte metoder for strukturert logging»?
De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.
Kan jeg skrive og kjøre kode i denne Håndbok for feilsøking i produksjon og hendelseshåndtering-leksjonen?
Ja. Alle Håndbok for feilsøking i produksjon og hendelseshåndtering-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.
Alle leksjonene i dette kurset
- Anbefalte metoder for strukturert logging
- Måledata, dashbord og observerbarhet
- Utforming av smarte varslingsstrategier
- Strategier for loggsamling og oppbevaring