Problem & Kontext der Logfile-Analyse

SEO-Teams sehen nur einen Teil der Wahrheit in der Google Search Console, Logs zeigen den Rest. Logs dokumentieren jeden Request: welcher Bot, welche URL, welcher Status, wie lange die Auslieferung dauerte. So lassen sich Crawl-Prioritäten, Sackgassen und technische Bremsen erkennen. KI-Bots wie GPTBot, Claude oder Perplexity greifen ebenfalls auf Inhalte zu. Ohne Loganalyse bleibt unklar, ob sie wichtige Seiten erreichen. Fehlkonfigurationen oder Ketten aus Weiterleitungen verschwenden Budget. Auch scheinbar kleine Latenzen summieren sich. Ziel ist ein sauberer Ablauf: Bots finden die richtigen Seiten, bekommen schnelle Antworten und stoßen nicht auf Fehler.

Was bei einer Logfile-Analyse wirklich zählt

1. Verlässliche Bot-Erkennung
   User-Agent allein reicht nicht. rDNS prüfen und mit Forward-DNS verifizieren. Nur so echte KI-Bots und Suchmaschinen von Spoofing trennen.
2. Crawl-Budget dorthin lenken, wo Wert entsteht
   Log-Hits, Status-Codes und TTFB verbinden. So werden 404/410-Häufungen, 301-Ketten, Soft-404 und langsame Endpunkte sichtbar.
3. Data Ops, nicht nur Reports
   Apache/Nginx-Logs strukturiert in ELK oder BigQuery laden. Queries und Dashboards standardisieren. Ergebnisse in konkrete Tickets überführen.

Schritt-für-Schritt-Vorgehen

1. Daten einsammeln & normalisieren
   • Logformat prüfen (Apache Combined, Nginx).
   • Ingest in ELK oder Upload nach BigQuery, Felder: timestamp, method, host, uri, status, bytes, ua, ip, response_time.
   • Bots segmentieren: Suchmaschinen, KI-Bots, Unbekannt.
2. Signale auswerten
   • Crawl-Pattern je Bot: Hits/URL, Status-Verteilung, TTFB.
   • Problem-Cluster: 404-Serien, 301-Schleifen, Bot-Zugriffe auf Noindex/Blocked-Pfad, große Dateien.
   • Wichtigkeit mit SEO-Signalen verknüpfen (Leit-URLs, Traffic-Seiten, Money-Content).
3. Priorisieren & Maßnahmen umsetzen
   • Redirect-Ketten kürzen, 404 zu 410/korrekte Ziele, dünne Seiten deindexieren oder verbessern.
   • robots.txt/Meta-Robots klären.
   • Templates und Medien optimieren, Caching/CDN prüfen.
   • Ergebnisse wieder im Log verifizieren.

Beispiele / Mini-Workflows für die Auswertung von Server-Logfiles

A) Crawl-Budget: schnelle Diagnose in BigQuery

1. Import: Externe Tabelle auf GCS-Bucket mit Access-Logs (CSV/NDJSON).
2. Query (vereinfachtes Muster):

   SELECT uri, COUNT(*) AS hits, ANY_VALUE(status) AS last_status
   FROM `project.dataset.logs`
   WHERE user_agent LIKE '%Googlebot%'
   GROUP BY uri
   ORDER BY hits DESC;
   

3. Aktion: URLs mit vielen Hits und problematischen Statuscodes priorisieren. 301-Ketten auflösen, 404 beheben, langsame Endpunkte profilieren.

B) KI-Bots erkennen (rDNS + Forward-Check)

1. rDNS prüfen: PTR-Lookup der IP (z. B. dig -x <IP> +short).
2. Forward bestätigen: Hostname wieder auflösen (dig <hostname> +short) und mit der ursprünglichen IP abgleichen.
3. Regel anwenden: Nur wenn beide Checks passen, als GPTBot/Claude/Perplexity zählen. Abweichungen flaggen oder blocken.

C) Loganalyse mit Screaming Frog Log File Analyser

1. Daten laden: Access-Log importieren, eigene Bots definieren (Pattern für GPTBot/Claude/Perplexity).
2. Mappen: Mit einem frischen Crawl kombinieren, um Status, Direktiven, Canonicals und interne Linktiefe neben Hits zu sehen.
3. Quick Wins: 404-Spitzen, 5xx-Antworten, langsame Templates, tiefe aber wichtige Seiten nach oben verlinken.

Häufige Fehler im Umgang mit Logfiles

• Nur User-Agent matchen
  Problem: Spoofing bleibt unentdeckt.
  Korrektur: Immer rDNS + Forward-DNS kombinieren, Ausnahmen dokumentieren.
• Logfiles nicht mit SEO-Daten verheiraten
  Problem: Viele Zahlen, wenig Handlung.
  Korrektur: Log-Hits je URL mit Status, Indexierungsstatus, interner Tiefe, Sitemaps, Traffic koppeln.
• Weiterleitungsketten ignorieren
  Problem: Budget-Verschwendung und Latenz.
  Korrektur: Max. eine Weiterleitung. Historisch entstandene Weiterleitungsketten vermeiden/auflösen.
• TTFB als Infrastrukturthema abtun
  Problem: Bots brechen tiefe Crawls ab.
  Korrektur: Caching, Datenbank-Queries, Bildgrößen und Edge-Delivery prüfen.

Praxis: Setups & Snippets

Nginx: sinnvolles Logformat

log_format main_ext '$remote_addr - $remote_user [$time_local] "$request" '
                    '$status $body_bytes_sent "$http_referer" "$http_user_agent" '
                    '$request_time $upstream_response_time $host';
access_log /var/log/nginx/access.log main_ext;

Nutzen: Enthält Request- und Upstream-Zeit, Host und User-Agent. Ideal für ELK/BigQuery.

Apache: Combined um Zeitfelder ergänzen

LogFormat "%h %l %u %t \"%r\" %>s %b \"%{Referer}i\" \"%{User-Agent}i\" %D" combined_ext
CustomLog logs/access_log combined_ext

%D liefert die Zeit in Mikrosekunden. Für TTFB/Response-Analysen hilfreich.

ELK: Grok-Beispiel (verkürzt, Nginx)

%{NGINXACCESS}

Verwende das NGINX-Access-Pattern als Basis und erweitere um $request_time/$upstream_response_time.

rDNS-Check: Shell-Beispiel

ip="<IP>"
host=$(dig -x "$ip" +short | head -n1)
fwd=$(dig "$host" +short | head -n1)
[ "$fwd" = "$ip" ] && echo "verifiziert" || echo "verdächtig"

Mini-Workflows für LLM-Sichtbarkeit

1) „Answer-Content“ für KI-Bots auffindbar machen

1. Logs filtern auf GPTBot/Claude/Perplexity (siehe hierzu auch die Logfile-Analyse im Kontext von LLMs); prüfen, ob Leit-FAQs, Glossare, How-tos besucht werden.
2. Lücken schließen: Interne Links zu diesen Antworten setzen; Sitemaps aktualisieren.
3. Verifizieren: Nach Änderungen prüfen, ob Bots die Seiten ansteuern.

2) Entity-Heatmap (Logs × Content-Entitäten)

1. Inhalte mit Entitäten taggen (z. B. über Content-Matrix oder Export).
2. Logs je Bot und Entität aggregieren (Pivot in BigQuery/ELK).
3. „Blinde Flecken“ priorisieren: wichtige Entitäten ohne Bot-Hits stärken (interne Links, Snippets, Datenseiten).

3) Fehlerbudget abbauen

1. Statuscodes clustern und nach Bot priorisieren.
2. 404/410 bereinigen oder gezielt ausschließen.
3. 5xx mit Infra-Team fixen, dann Log-Regression fahren.

Häufige Fragen und Antworten rund um die Logfile-Analyse

Warum Logs, wenn es die Google Search Console gibt?

Logs zeigen jede Anfrage, auch von KI-Bots und nicht indexierten URLs. Die Search Console deckt das Crawling im Rahmen der Crawling-Statistiken nur teilweise ab und blendet viele Details aus.

Wie erkenne ich echte KI-Bots sicher in meinen Logfiles?

User-Agent prüfen, dann rDNS und Forward-DNS abgleichen. Stimmen Hostname und IP überein, gilt der Bot als verifiziert.

Welche Tools eignen sich für den Einstieg in die Logfile-Analyse?

Screaming Frog Log File Analyser für schnelle Checks. ELK oder BigQuery für skalierbare, wiederholbare Analysen und Dashboards.

Was bringt mir TTFB in Logfiles?

TTFB zeigt, wie schnell Vorlagen antworten. Hohe Werte kosten Crawl-Budget und reduzieren die Tiefe der Bot-Besuche.

Wie häufig sollte ich Server-Logs auswerten?

Nach Releases/Neu-Veröffentlichungen und bei Traffic-/Ranking-Auffälligkeiten wie Core Updates. Zusätzlich ein regelmäßiger Standard-Report hilft, Drift früh zu erkennen.