Regarder/lire une croissance fichier journal

J'ai un fichier journal qui est en constante augmentation. Comment puis-je regarder et analyser via un script Ruby?

Le script va analyser chaque nouvelle ligne comme il est écrit dans le fichier de sortie et quelque chose à l'écran lorsque la nouvelle ligne contient la chaîne "ERREUR"

InformationsquelleAutor KingInk | 2009-08-18

io logging ruby

17
```
def watch_for(file, pattern)
  f = File.open(file,"r")
  f.seek(0,IO::SEEK_END)
  while true do
    select([f])
    line = f.gets
    puts "Found it! #{line}" if line=~pattern
  end
end

watch_for("g.txt",/ERROR/)
```
Merci pour le ezpz de l'idée, à l'aide de la méthode de sélection que vous obtenez ce que vous voulez.
La méthode de sélection est à l'écoute de l'IO de flux, de lire les octets d'où vient le "tard".
- Remarque: select retourne toujours immédiatement lorsqu'il est utilisé sur un flux de fichier: Vous pouvez toujours lire les expressions du FOLKLORE à partir de ce fichier de flux, de sorte que votre ruby processus finit par filer pendant qu'il attend pour le fichier de mise à jour. Les différents systèmes d'exploitation ont tendance à offrir des outils différents pour l'attente sur les fichiers, Linux a inotify et OS X a fsevents - il y a de pratique gems ruby, que de les emballer trop.
- -1 solution Stupide qui utilise 100% du CPU.
- Je pense que la raison pour laquelle il utilise 100% du CPU est parce que si vous supprimez la ligne qui dit if line=~pattern il continue juste retour des lignes vides même si il n'y a pas de nouvelle mise à jour. Je ne suis pas sûr de la façon de corriger moi-même, comme je viens de tombé sur ce problème.
- C'est est INCORRECT de la mise en œuvre, l'sélectionnez ici NE se bloquent PAS. Il fonctionne parce que vous lire les expressions du FOLKLORE qui ne parvient pas à la comparaison.
InformationsquelleAutor Qianjigui

Vous pouvez utiliser Kernel#select de la manière suivante:

def watch_for(file,pattern)
   f = File.open(file,"r")

   # Since this file exists and is growing, seek to the end of the most recent entry
   f.seek(0,IO::SEEK_END)

   while true
      select([f])
      puts "Found it!" if f.gets =~ pattern
   end
end

Puis l'appeler comme:

watch_for("some_file", /ERROR/)

J'ai ramené tous les contrôle d'erreur et de tel, vous voulez avoir que et probablement un mécanisme pour sortir de la boucle. Mais l'idée de base est là.

InformationsquelleAutor ezpz

Il y a deux approche:

sondage le fichier dans une boucle infinie (comme dans Qianjigui réponse, mais il est bon de mettre quelques sleep à l'intérieur de la boucle infinie)
utiliser OS de l'événement sous-système: kqueue sur BSD, inotify sur Linux

Voici un article que j'ai écrit à ce sujet: Ruby pour les Admins: Lecture de Fichiers Croissants. Ainsi, le programme combinant à la fois le système et les bureaux de ressemble à ceci:

def tail_dash_f(filename)
  open(ARGV.first) do |file|
    file.read          
    case RUBY_PLATFORM   # string with OS name, like "amd64-freebsd8"
    when /bsd/, /darwin/
      require 'rb-kqueue'
      queue = KQueue::Queue.new     
      queue.watch_file(ARGV.first, :extend) do
        yield file.read             
      end
      queue.run                     
    when /linux/
      require 'rb-inotify'
      queue = INotify::Notifier.new  
      queue.watch(ARGV.first, :modify) do
        yield file.read             
      end
      queue.run                      
    else
      loop do           
        changes = file.read
        unless changes.empty?  
          yield changes
        end
        sleep 1.0       
      end
    end
  end
end

tail_dash_f ARGV.first do |data|
  print data
  if data =~ /error/i
    # do something else, for example send an email to administrator
  end
end

InformationsquelleAutor Grych

5

Si vous êtes sur Linux...
```
tail -f log/development.log | grep "ERROR"
```
Sauf si vous voulais vraiment que ce soit un script Ruby pour une raison quelconque.
- Emballage ce, dans un script, vous donne la possibilité de réagir à une erreur d'une manière plus significative que par notant qu'elle a eu lieu. grepping est bon lorsque vous souhaitez traiter, mais il est assez limité dans sa capacité à invoquer le comportement dynamique.
- "...sortie de quelque chose à l'écran lorsque la nouvelle ligne contient la chaîne "ERREUR "" n'est pas le comportement dynamique 🙂
- Ce qui fonctionne le mieux pour moi. La méta-programmation autour du journal d'erreur semble que l'effort de mieux dépensé ailleurs.
- grâce ezpz c'est utile
InformationsquelleAutor cakeforcerberus
4

découvrez fichier-queue gem

InformationsquelleAutor
3

Pauvre homme à l'approche de pliage rapide:
1. un script Ruby qui ne
```
ARGF.each do |line|
  ...
```
2. Exécution d'écran:
```
tail -f file | ruby script 
```
InformationsquelleAutor reto

De travail sur l'idée de @Qianjigui mais de ne pas utiliser 100% du CPU:

def watch_for(file, pattern)
  # Replace -n0 with -n+1 if you want to read from the beginning of file
  f = IO.popen(%W[tail -f -n0 #{file}])
  loop do
    select([f])
    while line = f.gets
      puts "Found it! #{line}" if line =~ pattern
    end
  end
end

watch_for('g.txt', /ERROR/)

InformationsquelleAutor tig

Vous devez vous connecter pour publier un commentaire.