Apache/11 Logging/Skripte

Skripte

Log-Datei-Auswertung durch eigene Skripte

Für angepasste Einsatzzwecke lohnt es sich, eigene Skripte für die Auswertung von Log-Dateien zu schreiben. Die ideale Sprache dafür ist Perl, weil sich die Regeln zur Zerlegung der Dateien am besten durch reguläre Ausdrücke beschreiben lassen; diese sind bekanntlich in Perl perfekt integriert

In diesem Unterabschnitt werden drei kleine Skriptbeispiele betrachtet, die Ihnen einen Einblick in die vielfältigen Möglichkeiten geben. Davor werden hier noch die beiden regulären Ausdrücke vorgestellt, die das Common beziehungsweise das Combined Log Format erkennt.

Für das CLF gilt das folgende Ungetüm

^([^\s]+)\s+([^\s]+)\s+([^\s]+)\s+\[([^\]]+)\]\s+"([^"]+)"\s+
(\d+)\s+([\d\-]+)$

Die Teilausdrücke in den runden Klammern bilden die einzelnen Komponenten, die tatsächlich gefunden werden sollen. Viele von ihnen werden einfach durch [^\s]+ – ein oder mehrere Nicht-Leerzeichen – beschrieben, da sie jeweils durch Leerzeichen voneinander getrennt werden. Hinzu kommen die Sonderzeichen, die manche Bestandteile umschließen: Die eckigen Klammern um das Datum sowie die Anführungszeichen um die Anfrage (genau wie Referer und User-Agent beim Combined Log Format) stehen außerhalb der runden Klammern, werden also nicht mitgespeichert. Vorsichtshalber werden die Felder jeweils durch ein oder mehrere Leerzeichen (\s+) getrennt. Wichtig ist das Dollarzeichen als Abschlussmarkierung, da das Regexp ansonsten auch auf das Combined Log Format passen würde.

Dessen regulärer Ausdruck sieht entsprechend so aus

^([^\s]+)\s+([^\s]+)\s+([^\s]+)\s+\[([^\]]+)\]\s+"([^"]+)"\s+
(\d+)\s+([\d\-]+)\s+"([^"]+)"\s+"([^"]+)"

Der Vollständigkeit halber sei noch angemerkt, dass der beliebte deutsche Hoster 1&1 ein eigenes Log-Format verwendet, das sich mithilfe der nachfolgenden Skripte nicht verarbeiten lässt – vor dem Referer steht hier noch der Name des virtuellen Hosts; ganz am Ende kommt eine eventuelle Proxy-Liste (oder "-") hinzu. Der reguläre Ausdruck müsste entsprechend erweitert werden, was hier allerdings aus Platzgründen unterbleibt

Formatierte Ausgabe

Das erste Beispiel dient eher der Erläuterung der Grundlagen als der praktischen Nutzeranwendung. Es gibt die Komponenten jeder Log-Zeile in einem Format wie diesem aus

1. Format: Combined Log Format

Remote Host: 84.165.169.1
RFC 1413 ID: Remote User: Date/Time: 24/Aug/2011:00:00:53 +0200
HTTP Request: GET /it_komp/fragen.html HTTP/1.1
HTTP Status: 200
Content Length: 6337
Referer: http://buecher.lingoworld.de/it_komp/aus -wert.php
User Agent: Mozilla/4.0 (compatible; MSIE 6.0;
Windows  5.1; .NET CLR 1.1.4322)

Aufgerufen wird es mithilfe der folgenden Syntax

$ ./format_log.pl Logdatei [n]

Wenn Sie den zweiten Parameter (eine ganze Zahl) angeben, werden nur die ersten n Zeilen betrachtet. Die meisten echten Log-Dateien sind zu lang, um auf diese Weise behandelt zu werden

Listing 11.1 zeigt den vollständigen Code des Skripts. Sie finden es im Verzeichnis logscripts der beiliegenden DVD-ROM

#!/usr/bin/perl -w use strict;

# *****************************************
# * Skript: log_format.pl *
# * Apache-Logdateien formatiert ausgeben *
# * *
# * (C) 2005-2011, Sascha Kersken *
# * *
# * Free Software under the terms of the *
# * GNU General Public License, V2.0: *
# * www.gnu.org/licenses/gpl-2.0.html *
# *****************************************

# Namen der Logdatei von der Kommandozeile lesen my $logfile = $ARGV[0] || die "Verwendung: $0 Logdatei [n]\n";
# Eventuelle Höchstzahl lesen my $maxlines = $ARGV[1] || 0;

# Versuchen, die Logdatei zu öffnen open (LOG, "<$logfile") || die "Kann $logfile nicht öffnen\n";

# Variablen für die Logdatei-Bestandteile my ($host, $id1413, $uid, $date, $request, $status, $size, $referer, $useragent);

# Zähler, Gültigkeit der Zeile my $count = 1;
my $valid;

# Zeilenweise einlesen und auswerten while (my $line = <LOG>) {
chomp $line;
if ($line =~ /^([^\s]+)\s+([^\s]+)\s+([^\s]+)\s+
\[([^\]]+)\]\s+"([^"]+)"\s+(\d+)\s+([\d\-]+)$/) {
$valid = 1;
# Common Log Format zerlegen
($host, $id1413, $uid, $date, $request, $status, $size) =
($1, $2, $3, $4, $5, $6, $7);
# Fehlende Felder setzen
$referer = "[ohne]";
$useragent = "[ohne]";
print "$count. Format: Common Log Format\n";
} elsif ($line =~ /^([^\s]+)\s+([^\s]+)\s+([^\s]+)\s+
\[([^\]]+)\]\s+"([^"]+)"\s+(\d+)\s+([\d\-]+)\s+
"([^"]+)"\s+"([^"]+)"/) {
$valid = 1;
# Combined Log Format zerlegen
($host, $id1413, $uid, $date, $request, $status, $size, $referer, $useragent) =
($1, $2, $3, $4, $5, $6, $7, $8, $9);
print "$count. Format: Combined Log Format\n";
} else {
$valid = 0;
print "$count. Unrecognized line: \"$line\"\n\n";
}
# Ausgeben, falls gültig if ($valid) {
print " Remote Host: $host\n";
print " RFC 1413 ID: $id1413\n";
print " Remote User: $uid\n";
print " Date/Time: $date\n";
print " HTTP Request: $request\n";
print " HTTP Status: $status\n";
print " Content Length: $size\n";
print " Referer: $referer\n";
print " User Agent: $useragent\n\n";
}
# Zähler erhöhen
$count++;
# Beenden, falls begrenzt

last if $maxlines && $count > $maxlines;
}

Listing 11.1 log_format.pl; formatierte Ausgabe von Log-Dateien

Einfache Statistik

Interessanter als die einfache Formatierung ist es, die erhaltenen Daten statistisch auszuwerten. Das hier vorgestellte Perl-Skript beschränkt sich beispielhaft auf zwei typische Werte solcher Statistiken: die treuesten Besucher(-URLs) und die am häufigsten besuchten URLs, jeweils mit Angabe ihrer Anzahl. Als Pflichtparameter müssen Sie wieder den Namen einer Log-Datei angeben; optional können Sie zusätzlich die gewünschte Höchstzahl der Ergebnisse setzen (ansonsten wird 20 verwendet). Ein typischer Aufruf dieses Skripts mit seinem Ergebnis sieht so aus

$ ./log_stat.pl access_log 10
Die (bis zu) 10 haeufigsten Besucher

1. 66.246.218.107: 696
2. 213.160.11.114: 683
3. 66.249.65.67: 386
4. 65.54.188.71: 379
5. 81.173.174.49: 306
6. 213.196.248.98: 271
7. 66.249.65.133: 270
8. 213.196.241.196: 237
9. 66.249.65.79: 157
10. 87.78.46.0: 151

Die (bis zu) 10 haeufigsten erfolgreichen Anfragen

1. /main.css: 1791
2. /pixel.gif: 1771
3. /galileo.gif: 1593
4. /apache2/c_168_240.jpg: 1158
5. /apache2/noepatents.jpg: 1090
6. /it_komp/c_180_240.jpg: 409
7. /it_komp/noepatents.jpg: 345
8. /: 261
9. /fachinfo/c_190_240.jpg: 184
10. /apache2/mod_ssl.html: 170

In Listing 11.2 sehen Sie den Quellcode dieses Beispiels.

Die Funktionsweise dürfte durch die relativ ausführlichen Kommentare einigermaßen klar werden

#!/usr/bin/perl -w use strict;
# *****************************************
# * Skript: log_stat.pl *
# * Einfache Statistik für Web-Logdateien *
# * *
# * (C) 2005-2011, Sascha Kersken *
# * *
# * Free Software under the terms of the *
# * GNU General Public License, V2.0: *
# * www.gnu.org/licenses/gpl-2.0.html *
# *****************************************

# Namen der Logdatei von der Kommandozeile lesen my $logfile = $ARGV[0] || die "Verwendung: $0 Logdatei [Max]\n";
# Gewünschte Höchst-Zeilenzahl lesen oder auf 20 setzen my $maxlines = $ARGV[1] || 20;

# Versuchen, die Logdatei zu öffnen open (LOG, "<$logfile") || die "Kann $logfile nicht öffnen\n";

# Arrays für die Logdatei-Bestandteile my (@hosts, @ids, @uids, @dates, @requests, @status, @sizes, @referers, @useragents);

# Zeilenweise einlesen und auswerten while (my $line = <LOG>) {
chomp $line;
if ($line =~ /^([^\s]+)\s+([^\s]+)\s+([^\s]+)\s+
\[([^\]]+)\]\s+"([^"]+)"\s+(\d+)\s+([\d\-]+)$/) {
push @hosts, $1;
push @ids, $2;
push @uids, $3;
push @dates, $4;
push @requests, $5;
push @status, $6;
push @sizes, $7;
push @referers, "-";
push @useragents, "-";
} elsif ($line =~ /^([^\s]+)\s+([^\s]+)\s+([^\s]+)\s+
\[([^\]]+)\]\s+"([^"]+)"\s+(\d+)\s+([\d\-]+)\s+
"([^"]+)"\s+"([^"]+)"/) {
push @hosts, $1;
push @ids, $2;
push @uids, $3;
push @dates, $4;
push @requests, $5;
push @status, $6;
push @sizes, $7;
push @referers, $8;
push @useragents, $9;
}
}

# Anzahlen unterschiedlicher Hosts ermitteln my %sorthosts;
foreach my $host(@hosts) {
# Im Hash %sorthosts ist der Host der Schlüssel;
# der Wert dient als Zähler und wird um 1 erhöht
$sorthosts{$host}++;
}
print "Die (bis zu) $maxlines haeufigsten Besucher:\n\n";
my $c = 1;
foreach my $host
(sort {$sorthosts{$b} <=> $sorthosts{$a}} (keys %sorthosts)) {
print "$c. $host: ${sorthosts{$host}}\n";
$c++;
last if $c > $maxlines;
}
print "\n";

# Anzahlen unterschiedlicher erfolgreich angeforderter URLs my %sorturls;
my $i = 0;
foreach my $request(@requests) {
# URL aus dem Request ermitteln my $url;
if ($request =~ /[A-Z]+\s+([^\s]+)/) {
$url = $1;
}
# War diese Anfrage erfolgreich?
if ($status[$i] == 200) {
# URL zählen
$sorturls{$url}++;
}
$i++;
}
print "Die (bis zu) $maxlines haeufigsten erfolgreichen Anfragen:\n\
n";
$c = 1;
foreach my $url
(sort {$sorturls{$b} <=> $sorturls{$a}} (keys %sorturls)) {

print "$c. $url: ${sorturls{$url}}\n";
$c++;
last if $c > $maxlines;
}

Listing 11.2 log_stat.pl; einfache statistische Auswertung von Log-Dateien

Ein wenig kompliziert ist in diesem Beispiel das Verfahren zur sortierten Ausgabe der Hashes – diese sollen nämlich nicht nach ihren Schlüsseln (den IP-Adressen beziehungsweise URL-Pfaden), sondern nach den Werten sortiert werden. Die Perl-Funktion sort() erlaubt für solche Zwecke die Angabe einer Sortiervorschrift in Form einer eingebetteten Funktion. Die stilisierten Variablen $a und $b geben die Reihenfolge an. Für numerische Vergleiche wird der spezielle Operator <=> verwendet, während die String-Sortierung durch cmp geregelt wird. Beispielsweise werden die URL-Pfade wie folgt absteigend nach ihrer Anzahl sortiert

sort {$sorturls{$b} <=> $sorturls{$a}} (keys %sorturls)

Die Log-Daten in eine Datenbank übernehmen Das letzte Beispielskript erfüllt eine besonders nützliche Aufgabe: Es schreibt die Inhalte der angegebenen Log-Datei in eine MySQL-Datenbank. Zu diesem Zweck müssen Sie eine Datenbank namens log mit einer Tabelle namens logs anlegen Im Kommandozeilen-Client mysql (siehe Kapitel 15, Technologien zur Webprogrammierung) sehen die entsprechenden Anweisungen so aus

mysql> CREATE DATABASE log;
mysql> USE log mysql> CREATE TABLE logs (
-> id INT AUTO_INCREMENT, -> host VARCHAR(50), -> rid VARCHAR(30), -> uid VARCHAR(30), -> rdate DATETIME, -> request VARCHAR(400), -> status INT, -> size INT, -> referer VARCHAR(400), -> useragent VARCHAR(200), -> PRIMARY KEY (id)
-> );

Näheres über die Perl-Datenbankschnittstelle DBI, die für die Datenbankverbindung eingesetzt wird, erfahren Sie ebenfalls in Kapitel 15, Technologien zur Webprogrammierung. Wichtig ist hier, dass Sie username und password durch die korrekten Werte für Ihren eigenen MySQL-Server ersetzen

#!/usr/bin/perl -w use strict;
use DBI;

# *****************************************
# * Skript: log2db.pl *
# * Web-Logdateien in MySQL-DB schreiben *
# * *
# * (C) 2005-2011, Sascha Kersken *
# * *
# * Free Software under the terms of the *
# * GNU General Public License, V2.0: *
# * www.gnu.org/licenses/gpl-2.0.html *
# *****************************************

# Namen der Logdatei von der Kommandozeile lesen my $logfile = $ARGV[0] || die "Verwendung: $0 Logdatei\n";

# Verbindung zur MySQL-Datenbank herstellen my $conn = DBI->connect ("dbi:mysql:log;localhost", "username", "password") ||
die "Kann Datenbankverbindung nicht herstellen\n";

# Versuchen, die Logdatei zu öffnen open (LOG, "<$logfile") || die "Kann $logfile nicht öffnen\n";

# Variablen für die Logdatei-Bestandteile my ($host, $id, $uid, $date, $request, $status, $size, $referer, $useragent);

# Gültigkeit der Zeile my $valid;

# Monate für die Datumsumwandlung my %months = (
Jan => '01', Feb => '02', Mar => '03', Apr => '04', May => '05', Jun => '06', Jul => '07', Aug => '08', Sep => '09', Oct => '10',

Nov => '11', Dec => '12'
);

# Zeilenweise einlesen und in die DB schreiben while (my $line = <LOG>) {
chomp $line;
if ($line =~ /^([^\s]+)\s+([^\s]+)\s+([^\s]+)\s+
\[([^\]]+)\]\s+"([^"]+)"\s+(\d+)\s+([\d\-]+)$/) {
# Gültig
$valid = 1;
# Bestandteile übernehmen
$host = $1;
$id = $2;
$uid = $3;
$date = $4;
$request = $5;
$status = $6;
$size = $7;
$referer = "-";
$useragent = "-";
} elsif ($line =~ /^([^\s]+)\s+([^\s]+)\s+([^\s]+)\s+
\[([^\]]+)\]\s+"([^"]+)"\s+(\d+)\s+
([\d\-]+)\s+"([^"]+)"\s+"([^"]+)"/) {
# Gültig
$valid = 1;
# Bestandteile übernehmen
$host = $1;
$id = $2;
$uid = $3;
$date = $4;
$request = $5;
$status = $6;
$size = $7;
$referer = $8;
$useragent = $9;
} else {
# Ungültig
$valid = 0;
}
# Daten in die Datenbank schreiben, falls gültig if ($valid) {
# Datum in SQL-Format umwandeln, z.B
# 24/Oct/2005:00:06:58 +0200 -> "2005-10-24 00:06:58"
my $sqldate;
if ($date =~m|(\d+)/([A-Za-z]+)/(\d+):(\d+):(\d+):(\d+)|) {
$sqldate = "$3-".$months{$2}."-$1 $4:$5:$6";
}
# "-" in Content-Length durch 0 ersetzen
$size =~ s/\-/0/;
# Die SQL-Abfrage my $q = "INSERT INTO logs
(host, rid, uid, rdate, request, status, size, referer, useragent)
VALUES (\"$host\", \"$id\", \"$uid\", \"$sqldate\", \"$request\", \"$status\", \"$size\", \"$referer\", \"$useragent\")";
# Abfrage durchführen
$conn->do ($q);
}
}

Listing 11.3 log2db.pl; Log-Datei-Inhalte in eine MySQL-Datenbank schreiben

Befinden sich die Daten erst einmal in der Datenbank, können Sie beliebige SQLOperationen damit ausführen – die Erstellung eigener Statistiken wird so noch leichter. Abbildung 11.1 zeigt einen kleinen Ausschnitt der Daten in der webbasierten MySQL-Arbeitsoberfläche phpMyAdmin

Abbildung 11.1 Ein Ausschnitt einer in die Datenbank übernommenen Log-Datei in phpMyAdmin

Hier noch ein Beispiel für eine SQL-Abfrage zur statistischen Auswertung. Sie liefert die zehn Hosts mit den meisten Seitenaufrufen, genau wie das weiter oben vorgestellte Statistikskript. Sie können die Abfrage sowohl im KommandozeilenClient als auch in phpMyAdmin eingeben, sobald Sie log als Standarddatenbank ausgewählt haben

mysql> SELECT host, COUNT(*) AS Besuche FROM logs GROUP BY host
-> ORDER BY Besuche DESC LIMIT 0,10;
+-----------------+---------+
| host | Besuche |
+-----------------+---------+
| 66.246.218.107 | 696 |
| 213.160.11.114 | 683 |
| 66.249.65.67 | 386 |
| 65.54.188.71 | 379 |
| 81.173.174.49 | 306 |
| 213.196.248.98 | 271 |
| 66.249.65.133 | 270 |
| 213.196.241.196 | 237 |
| 66.249.65.79 | 157 |
| 87.78.46.0 | 151 |
+-----------------+---------+

Weitere Informationen zur MySQL-Syntax würden den Rahmen dieses Buches sprengen. Wenn Sie sich für MySQL und seine Möglichkeiten interessieren, kann ich Ihnen mein Buch Praktischer Einstieg in MySQL mit PHP (2. Auflage; Köln 2007, O’Reilly Verlag) empfehlen.1

Wenn Sie die Verwaltung von Log-Daten in einer Datenbank nützlich finden, können Sie alternativ auch auf diverse Drittanbieter-Module zurückgreifen, beispielsweise mod_log_mysql für MySQL-Datenbanken. Einige dieser Module werden in Kapitel 17, Apache erweitern, erwähnt