Bonjour,
 
Je cherche 2 ou 3 testeurs pour un petit script d'analyse de logs (en python).
Ca marche chez moi, mais je souhaiterais une vérification par un tiers avant de développer plus le concept. Le mieux serait de tester /var/log/message ou /var/log/auth.log, et tout autre type de logs.
 
Le script est concu pour aider à l'analyse de logs de tout types, et se veut générique. Il regroupe les informations par lots, selon un paramètre de sensibilité défini par l'utilisateur, puis fait un compte rendu.
C'est tout con, mais ca semble prometteur    
 
Les versions à venir doivent pouvoir extraire les contenus désirés pour les écrire dans un fichier, et/ou faire une seconde analyse plus fine sur un lot particulier (2ieme voir 3ieme niveau d'analyse). Une fois fonctionnel, et si ca à un intérêt, je mettrais les sources en ligne.
 
Une bonne âme pour tester ? Je donne le script par MP, contre promesse de ne pas diffuser pour le moment.
 
Zaft
 
Edit : petite précision, ce script a pour vocation de pouvoir être utilisé à distance sur un serveur, sans ajout de paquets/modules. Il tourne donc avec un python de base.

Je suis intéressé pour sa lecture et pour voir comment tu fais, mais je suis plutôt sur Perl donc pour le débug pur et dur faudra pas compter sur moi
 
Je suis intéressé pour la partie "présentation", car on trouve surtout de la mise en page au format HTML à exposer via un serveur web, or je suis plutôt à la recherche de quelque chose qui soit capable de basculer sur du XML, voire d’interagir automatiquement par l'envoi d'un mail suivant l'option choisie par l'admin.
 
Il pourrait être intéressant d'avoir un "mini forum" dédié, avec accès réservé pour pouvoir discuter entre testeurs et développeur

Fous le sur Github, et balance
 
Par contre, j'suis plus testeur, que dev.
du coup, j'te renvoie mes apprioris etc.  
Je ne peux pas te donner de lecon ;P

sans être intéressé par le script en lui meme, je vais quand meme poser la question : pourquoi réinventer la roue, et au passage la rendre carrée ? logwatch fait ça très bien deja.
 
si tu veux aller un peu plus loin qu'une machine, aujourd'hui le pattern classique des logs c'est celui du pipeline unique, et les consommateurs qui viennent se plugger dessus (analyzer, stockage, etc)

Tu dis:  
"pourquoi réinventer la roue, et au passage la rendre carrée ?"
 
C'est faut.
il existe multiple OS Linux. Pourtant, chacun à réinventer la roue. Partant du noyau, on a du Debian, du Arch, du BSD... Parfois, les roues sont plus ronde. Et souvent, plus adapter a différent type de personne.
(Pneu neige, pluie, course.. Ce sont tous des pneus, non? )

Ton analogie est foireuse

Ce que je veux dire c'est qu'il y a fort à parier que son script est moins versatile et plus buggé que l'existant. Je n'ai meme pas parlé de portabilité du script entre les différents OS.
BTW, je fais juste part de mon XP, pour avoir pratiqué un peu la gestion de logs à des volumes "raisonnables"

edit : je dis pas que c'est mal d'écrire son propre soft, je le fais régulièrement pour répondre à des besoins précis non couverts par les différents softs existants

Merci de vos retours.
 
bardiel et feliwyn je met le script directement ici finalement, il tourne mieux maintenant
Si le script est vraiment utile (automatisable), je rajouterai l'XML en sortie.
Ce n'est pas assez mature pour être mis sur GitHub, d'autant que c'est la première fois que j’utilise du python, le code est donc immonde et probablement non conforme à la philosophie du langage. Mais ça tourne pour le "proof of concept", c'est déjà ça.
 
Pour répondre à la question de l'utilité (je me suis posé la même, et je pose sur le forum aussi pour voir si ça peux servir), disons que j'utilise Logwatch quotidiennement, mais qu'il n'est pas capable de gérer certaines logs exotiques. Exemple : sur l'un des serveurs, nous avons du système de fichier Lustre. C'est particulièrement verbeux, et pour retrouver une erreur là dedans lorsque nous en suspectons une, c'est la croix et la bannière car le type d'erreur peut être différent à chaque fois (ce qui exclus le grep). De plus, logwatch nécessite l'installation d'un package et de ses quelques dépendances, ce qui est proscrit sur certaines de nos nodes, alors que python y est nativement dans sa version basique, d'où l'usage d'un script de ce type, que je peux pousser et utiliser à la volée par ssh sans avoir à rajouter autre chose.
J'ai donc bien conscience que l'outil n'a pas vocation à remplacer les existants, mais plutôt à s'adapter aux situations inhabituelles et répondre à une niche d'utilisateurs (dont je fait parti dans ce cas) pour une niche d'utilisation.
 
Voilà comment ça marche, le code suit :
 
Lancer le script avec la commande "python test.py" (en supposant que le fichier est nommé test.py).
Renseigner la position du log à lire (en supposant que le fichier est lisible, attention aux droits), et ne pas oublier les "" autour de la chaine.
Renseigner la valeur de sensibilité. Je recommande de tester 0.6 à 0.7 pour commencer, sinon ca fait trop de lots.
Ca mouline un peu.
Et ensuite le rapport affiche les lignes identifiées par lots de similarité et rangé dans l'ordre du plus présent au moins présent. Chaque ensemble se voit donner un numéro (tag). Dans cette vue là, il est déjà possible de voir si quelque chose de particulier se niche dans le log.
Ensuite plusieurs possibilités :
La fonction 0 (refaire l'analyse) ne marche pas, inutile d'essayer.
La fonction 1 (expand en lvl 2) n'est pas très intéressante, mais est fonctionnelle.
La fonction 2 (suppression de tags) est plus utile, dans mon usage en tous cas.
Chaque bloc affiché s'est vu donné un tag. Il est possible ainsi de supprimer certains blocs, notamment les plus gros qui correspondent souvent aux messages d'utilisation normale, et ainsi réduire à ce qui nous intéresse. Ensuite on écrit le log résultant. Et après, et bien si besoin, on peut refaire une analyse sur ce log (pour trier plus finement, en changeant le facteur de sensibilité (plus grand)), ou étudier le log à la main puisque qu'il est nettement plus court.
 
Attention aux yeux, c'est pas ergonomique et c'est moche

Le code :
 

# Generic Log analyser v1.0
# Zaft
 
# To use this script, set the logfile name and location,
# and adjust 'match' variable between 0 and 1 (0.7 and 0.8 are good)
 
logfile = input('Enter log file position (ex "/var/log/auth.log", do not forget brackets) :\n')
#logfile="log4"
match = input('Enter sensibility value (match factor), between 0 and 1 (0.6 to 0.7 is a good starting range of values) :\n')
#match=0.7
 
# Import sys
import sys
sys.stdout.flush()
 
# Import and define sequence matcher
from difflib import SequenceMatcher
def similar(a, b):
    return SequenceMatcher(None, a, b).ratio()
 
# Open log file
with open (logfile, "r" ) as myfile:
    data = myfile.readlines()
 
# Allocate memory
datasize = len(data)
data_tag = range(datasize)
 
knowndata_s = range(datasize) # more than needed, to be optimized
knowndata_tot = range(datasize) # same
 
# Init first patern
knowndatasize = 1
knowndata_s[0] = data[0]
knowndata_tot[0] = 1
 
flag = 0
c = 0
 
print
print 'Analysing....  ',
 
# Loop on all lines of file
for i in range (1,datasize):
   # Check if data is already registered as patern
    # Loop on all already known patern
    for j in range (0,knowndatasize):
        if similar(data[i],knowndata_s[j]) > match: # 0.8 seems good for auth.log
            # Data already known, increment and skip to next data
            knowndata_tot[j] = knowndata_tot[j] + 1
            data_tag[i] = j
            flag = 1
            break
    # Data not already registered, create a new patern
    if flag == 0:
        knowndata_s[knowndatasize] = data[i]
        knowndata_tot[knowndatasize] = 1
        data_tag[i] = knowndatasize
        knowndatasize = knowndatasize + 1
    else:
        flag = 0
 
    # Display work in progress
    if c == 20: 
        sys.stdout.write('\b/')
    elif c == 40: 
        sys.stdout.write('\b-')
    elif c == 60:
        sys.stdout.write('\b\\')
    elif c == 80: 
        sys.stdout.write('\b|')
        c = 0
    sys.stdout.flush()
    c = c + 1
 
print '\b\b done!'
 
 
print 'Sorting results....  ',
knowndata_tag = range(knowndatasize)
# Sort results for display only
knowndata_tot_d, knowndata_s_d = (list(t) for t in zip(*sorted(zip(knowndata_tot[0:knowndatasize], knowndata_s[0:knowndatasize]))))
knowndata_tot_d, knowndata_tag_d = (list(t) for t in zip(*sorted(zip(knowndata_tot[0:knowndatasize], knowndata_tag[0:knowndatasize]))))
print '\b\b done!'
 
# Print results
print
print "########################################################"
print "############# Found ",knowndatasize," different paterns"
print "#####"
print
 
for j in range (0,knowndatasize):
    print "----> tag :",knowndata_tag_d[j]," found ",knowndata_tot_d[j], " time(s) : ", knowndata_s_d[j]
 
# Extract desired tag for lvl 2 analysis
 
#while exit
print
print "What do you want to do ?"
print "0 . Redo analysis with a different match parameter"
print "1 . Lvl 2 analysis (redo analysis on part or previous analysis to expand a specific part)"
print "2 . Purge log from specific lines and write result to file"
#print "      Note : you can redo an analysis on this file after with a different match parameter to expand"
value = input("      Note : you can redo an analysis on this file after with a different match parameter to expand\n" )
 
if value == 2:
    flag = 0
    data_tag_remove = range(knowndatasize)
    rm = 0
    data_tag_remove[0] = input("Which tag do you want to remove ?\n" )
    while flag == 0:
        value = input("Which tag do you also want to remove ? (-1 to print current state, -2 validate and write)\n" )
        if value == -2:
            flag = 1
        elif value == -1:
            print
            print "########################################################"
            print "############# Update"
            print "#####"
            print
            print "Tags to be removed :",data_tag_remove[0:rm]
            print
            print "To be written :"
            print
            for j in range (0,knowndatasize):
                flag1 = 0
                for i in range (0,rm+1):
                    if knowndata_tag_d[j] == data_tag_remove[i]:
                        flag1 = 1
                if flag1 == 0:
                    print "tag :",knowndata_tag_d[j]," found ",knowndata_tot_d[j], " time(s) : ", knowndata_s_d[j]
        else:
            rm = rm + 1
            data_tag_remove[rm] = value
    filename = input('Enter file name and position (ex : "/home/sphen/log.out" , do not forget brackets) :\n')
    print 'Writing to file....  ',
    with open (filename, "w" ) as myfile2:
        for i in range (0,datasize):
            flag = 0
            for j in range (0,rm+1):
                if data_tag[i] == data_tag_remove[j]:
                    flag = 1
            if flag == 0:
                myfile2.write(data[i])
    print '\b\b done!'
    quit()
 
elif value == 1:
    l2_tag = input("Which tag for lvl 2 analysis ?\n" )
    print "Which match for lvl 2 analysis ? Must be > ",match
    l2_match = input("\n" )
    c = 0
 
 
    # Extract lvl 2 data from lvl 1 data
    l2_datasize = knowndata_tot[l2_tag]
    l2_data = range(l2_datasize)
    for i in range (0,datasize):
        if data_tag[i] == l2_tag:
            l2_data[c] = data[i]
            c = c + 1
 
    l2_knowndata_s = range(l2_datasize) # more than needed, to be optimized
    l2_knowndata_tot = range(l2_datasize) # same
 
    # Init first patern
    l2_knowndatasize = 1
    l2_knowndata_s[0] = l2_data[0]
    l2_knowndata_tot[0] = 1
 
 
    c = 0
 
    print
    print 'Analysing l2....  ',
 
 
    for i in range (1,l2_datasize):
       # Check if data is already registered as patern
        # Loop on all already known patern
        for j in range (0,l2_knowndatasize):
            if similar(l2_data[i],l2_knowndata_s[j]) > l2_match: # 0.9 seems good for auth.log
                # Data already known, increment and skip to next data
                l2_knowndata_tot[j] = l2_knowndata_tot[j] + 1
                flag = 1
                break
        # Data not already registered, create a new patern
        if flag == 0:
            l2_knowndata_s[l2_knowndatasize] = l2_data[i]
            l2_knowndata_tot[l2_knowndatasize] = 1
            l2_knowndatasize = l2_knowndatasize + 1
        else:
            flag = 0
 
        # Display work in progress
        if c == 4: 
            sys.stdout.write('\b/')
        elif c == 8: 
            sys.stdout.write('\b-')
        elif c == 12:
            sys.stdout.write('\b\\')
        elif c == 16: 
            sys.stdout.write('\b|')
            c = 0
        sys.stdout.flush()
        c = c + 1
 
    print '\b\b done!'
 
    print 'Sorting results l2....  ',
    # Sort results for display only
    l2_knowndata_tot_d, l2_knowndata_s_d = (list(t) for t in zip(*sorted(zip(l2_knowndata_tot[0:l2_knowndatasize], l2_knowndata_s[0:l2_knowndatasize]))))
    print '\b\b done!'
 
    # Print results
    print "###############################"
    print "# Found ",l2_knowndatasize," different paterns"
    print "###############################"
    for j in range (0,l2_knowndatasize):
        print " found ",l2_knowndata_tot_d[j], " time(s) : ", l2_knowndata_s_d[j]

 
 
edit coloration syntaxique // black_lord

Comme Black_Lord, généralement les logs ça s'exporte. Les analyses se font sur d'autre machines faites pour cela avec les apps et les ressources pour cela.
 

Certes, vous marquez un point là dessus

C'est surtout une des bases. une des raisons est que si ta machine crashe, t'es content d'avoir les logs ailleurs. Tu as plein d'autres raisons de le faire : remplissage des disques locaux, leur utilisation (== perfs), la centralisation des infos, la sécurité (machine compromise). Cette liste c'est juste les premiers trucs qui me viennent à l'esprit.
 
Syslog fait ça très, et je ne connais aucun admin qui ne fasse pas ça.
 
Dans un cas comme le tien, c'est encore plus utile. tu n'as ton script à deployer qu'une fois (par collecteur on va dire). du coup tu peux te permettre des choses plus fancy au niveau des deps aussi. Bref, au delà du sujet du script, tu devrais penser à envoyer tes logs en remote.

Ce n'est pas moi qui ai déployé ces machines, mais aujourd'hui les logs sont éparpillées sur les nodes (à noter qu'il y a des centaines de nodes). Sur une autre machine, a été utilisé un montage NFS, mais personnellement ca m'a semblé délirant.
Pour le moment, je rapatrie les logs par ssh, avec un user particulier qui fait un sudo cat sur les logs. Mais j'ai commencé à réaliser qu'il existe de nombreux outils (souvent plus viables que les scripts maisons) et qu'il est dommage de s'en priver.
 
Le fonctionnement de syslog répond effectivement parfaitement et simplement à ce problème. Je vais soumettre l'évolution et le déployer.
 
Bon et ce script d'analyse alors, ca vous semble utile ? Pour tracker un évènement particulier dans des logs non prises en charge par logwatch ?
 
Edit : d'ailleurs je pense que je ne vais pas tarder à soumettre un topic où j'exposerai comment je fait pour administrer mes machines, et où vous pourrez vous donner à coeur joie de démonter mon oeuvre et de m'indiquer des solutions plus propres.

 

 

 
des centaines de nodes, rassure moi : (tu|vous) utilise(s|z) un système de config management ?
 

 
C'est désigné pour
 

 
par curiosité, tu as quelle XP en tant que sysadmin ?

Je suggère que l'on discute de ça par MP, ca sort du cadre du topic.
 
Je te répond de suite par MP.

ok