Ruby: Proxy-Muster, reduzierende Methodenaufrufe

Question

Wie berechtige ich den Ruby Logger und halte die Leistung?

So haben wir eine Anforderung bei der Arbeit, ganz in Ordnung. Wenn ein Programm gesendet wird, wird das Signal HUP das Protokoll gelöscht und neu gestartet.

Das Problem ist, dass, wenn context.logger zurückgesetzt wird, @logger immer noch auf den alten verweist.

Also, ich dachte, ich würde Proxy-Logger:

class LoggerProxy 
    attr_accessor :logger 

    def debug *args 
    @logger.send :debug, args 
    end 

    def info *args 
    @logger.send :info, args 
    end 
end 

context.logger = LoggerProxy.new 
context.logger.logger = Logger.new 'my_file.log' 

Signal.trap('HUP') { 
    context.logger.logger = Logger.new 'my_file.log' 
} 
... 
@logger = context.logger 
@logger.info "Hello world" 

Dies funktioniert gut, außer ich ein Methodenaufruf für 2 Methodenaufrufe gehandelt haben (1 Accessor, die den Logger zurückgibt). Ich muss noch LoggerProxy.:debug,: info, ... aufrufen, was wiederum den ursprünglichen Logger aufruft! Ergo, 2 Methoden Anrufe, wo es einen gab.

Ich möchte nicht mit Logger-Klasse, oder überladen es, weil ich andere Logger in der Zukunft, syslog verwenden möchte, rollen meine eigenen oder einige solcher.

Gibt es eine Möglichkeit, die Anzahl der Methodenaufrufe für die Leistung zu reduzieren?

-Daniel

Update: als Reaktion auf eine Leistung Frage, hier ist die Probe-Test.

require 'logger' 
require 'benchmark'; 

class MyLogger 

    attr_accessor :logger 

    def info msg 
    @logger.info msg 
    end 

end 

myLogger = Logger.new '/dev/null' # dev null to avoid IO issues 
myLoggerProxy = MyLogger.new 
myLoggerProxy.logger = myLogger 

n = 100000 
Benchmark.bm do | benchmarker | 
    # plain logger 
    benchmarker.report { n.times { myLogger.info 'opps' } } 

    # via accessor 
    benchmarker.report { n.times { myLoggerProxy.logger.info 'opps' } } 

    # via proxy 
    benchmarker.report { n.times { myLoggerProxy.info 'opps' } } 
end 


     user  system  total  real 
    1.580000 0.150000 1.730000 ( 1.734956) 
    1.600000 0.150000 1.750000 ( 1.747969) 
    1.610000 0.160000 1.770000 ( 1.767886) 

Answer 1

Erstens: Ihre Frage riecht wie Sie vorzeitig zu optimieren sind. Sie sollten nur optimieren, wenn Sie wissen Ihr Code ist zu langsam. (Und Ihre Benchmark-Show nur ein winziger Unterschied)

Das heißt, Sie den Kontext jeder Proxy mitteilen machen könnte, wenn Logger jemals aktualisiert:

class ProxyLogger 
    attr_accessor :logger 

    def initialize(context) 
    context.register(self) 
    end 
end 

class Context 
    attr_accessor :logger 

    def initialize 
    @proxies = [] 
    end 

    def logger=(val) 
    @logger = val 
    @proxies.each { |p| p.logger = val } 
    end 

    def register(proxy) 
    @proxies << proxy 
    end 
end 

aber wieder, ist dies scheint nicht wirklich lohnt sich die zusätzliche Komplexität .

(verwandt: this is a very nice presentation showing @tenderlove optimizing the ARel gem)

Answer 2

Statt der Logger selbst zurückzusetzen, bündig und öffnen Sie seine Ausgabe:

logfile = File.open 'my_file.log', 'w+' 
context.logger = Logger.new logfile 

Signal.trap('HUP') { 
    logfile.flush 
    logfile.reopen 'my_file.log', 'w+' 
}