Existe-t-il une bibliothèque de journalisation asynchrone pour Ruby?

Question

La journalisation synchrone entraîne une pénalité de performance importante, car elle peut bloquer. Existe-t-il une bibliothèque Ruby autonome qui effectue une journalisation asynchrone (log4r ne semble pas le faire)? Puis-je modifier l'enregistreur de bibliothèque standard pour se connecter de manière asynchrone? Je cherche quelque chose comme AsyncAppender de log4j - mais de préférence une implémentation qui utilise les blocs de code de Ruby pour déplacer le plus de travail possible vers le thread d'arrière-plan.

Answer 1

Je sais que vous ne devriez pas vraiment répondre à votre question, mais il semble que tout est facile à rubis:

require 'thread' 
require 'singleton' 
require 'delegate' 
require 'monitor' 

class Async 
    include Singleton 

    def initialize 
    @queue = Queue.new 
    Thread.new { loop { @queue.pop.call } } 
    end 

    def run(&blk) 
    @queue.push blk 
    end 
end 

class Work < Delegator 
    include MonitorMixin 

    def initialize(&work) 
    super work; @work, @done, @lock = work, false, new_cond 
    end 

    def calc 
    synchronize { 
     @result, @done = @work.call, true; 
     @lock.signal 
    } 
    end 

    def __getobj__ 
    synchronize { @lock.wait_while { !@done } } 
    @result 
    end 
end 

Module.class.class_exec { 
    def async(*method_names) 
    method_names.each do |method_name| 
     original_method = instance_method(method_name) 
     define_method(method_name) do |*args,&blk| 
     work = Work.new { original_method.bind(self).call(*args,&blk) } 
     Async.instance.run { work.calc } 
     return work 
     end 
    end 
    end 
} 

Et pour mon exemple d'enregistrement:

require 'Logger' 
class Logger 
    async :debug 
end 
log = Logger.new STDOUT 
log.debug "heloo" 

Comme valeurs de retour travail, vous pouvez l'utiliser pour à peu près n'importe quoi:

require "test/unit" 
class ReturnValues < Test::Unit::TestCase 
    def do_it 
    5 + 7 
    end 
    async :do_it 
    def test_simple 
    assert_equal 10, do_it - 2 
    end 
end 

Answer 2

Aucune expérience personnelle avec ce:

• https://github.com/dirs/analogger

Le Swiftcore Analogger met en œuvre un système d'enregistrement asynchrone rapide pour les programmes Ruby ainsi que la bibliothèque client pour envoyer des messages de journalisation à la Processus Analogger.

Analogger accepte les journaux provenant de sources multiples et peut avoir plusieurs destinations de journalisation . Actuellement, la connexion à un fichier, à STDOUT ou à STDERR est prise en charge. Une révision future peut également prendre en charge la journalisation vers une destination de base de données .

Analogger dépend eventmachine (http://rubyforge.org/projects/eventmachine) pour fournir le cadre pour les communications réseau, bien que EM est non utilisé pour la bibliothèque cliente.

Answer 3

Le construit en classe Logger est thread déjà sûr

Answer 4

Commander Dunder https://github.com/fonsan/dunder

J'ai créé ce petit bijou il y a 6 mois qui fait exactement cela et plus