Wie definiert man eine gemeinsame Modulprotokollierung unter anderen Modul

Question

Ich entwickle ein Skript mit einer großen Hauptfunktion, die ich in mehrere Module aufgeteilt habe. Was ich brauche, ist Zugriff auf die Protokollfunktionalität von allen, das bedeutet, dass die Protokolldatei nur einmal geöffnet werden muss und der Zugriff freigegeben werden muss. Diese

ist, was ich habe:

require 'module_1' 
require 'module_2' 
require 'module_3' 

module Main 
Module_1.Function_startup() 
Module_2.Function_configuration() 
Module_3.Function_self_test() 
end 

Hier wird das verschmutzte Modul für den Logger ist ich in allen anderen Modulen zur Verfügung benötigen. Idealerweise würde ich es als "logger.error" bezeichnen, wobei "logger" die Instanz des Loggers zurückgibt und "error" der Funktionsaufruf bei rlogger als rlogger.error ist.

require 'logger' 

module Logging 
    @rlogger = nil 

    def init_logger 
     if @rlogger.nil? 
     puts "initializing logger" 
     file_path = File.join(File.dirname(__FILE__), 'checker.log') 
     open_mode = File::TRUNC# or File::APPEND 
     file = File.open(file_path, File::WRONLY | open_mode) 

     @rlogger = Logger.new(file) 
     @rlogger.datetime_format = "%Y-%m-%d %H:%M:%S" 

     @rlogger.formatter = proc do |severity, datetime, progname, msg| 
      con_msg = "" 
      if msg.match("ERROR:") 
      con_msg = msg.color(:red) 
      elsif msg.match("OK!") 
      con_msg = msg.color(:green) 
      else 
      con_msg = msg 
      end 
      puts ">>>#{con_msg}" 
      # notice that the colors introduce extra non-printable characters 
      # which are not nice in the log file. 
      "#{datetime}: #{msg}\n" 
     end 

     # Here is the first log entry 
     @rlogger.info('Initialize') {"#{Time.new.strftime("%H-%M-%S")}: Checker v#{@version}"} 
     end 
    end 

    # returns the logger 
    def logger 
     if @rlogger.nil? 
     puts "requesting nil rlogger" 
     end 
     @rlogger 
    end 
    end 
end 

Answer 1

Kurz nach benötigen Sie dieses Stück Code hinzufügen können

$FILE_LOG = Logging.create_log(File.expand_path('LoggingFile.log'), Logger::DEBUG) 

Erklärung der obigen Zeile: Es wird eine Funktion im Logging-Modul aufrufen, Datei zu erstellen, ist Protokollebene debuggen.

unten ist das Stück Code für Module

module Logging 
    def self.create_log(output_location level) 
    log = Logger.new(output_location, 'weekly').tap do |l| 
     next unless l 

     l.level = level 

     l.progname = File.basename($0) 

     l.datetime_format = DateTime.iso8601 

     l.formatter = proc { |severity, datetime, progname, msg| "#{severity}: #{datetime} - (#{progname}) : #{msg}\n" } 
    end 

    log.level = level if level < log.level 
    log 
    end 


    def self.log(msg, level) 
    # Here I am just logging only FATAL and DEBUG, similarly you can add in different level of logs 
    if level == :FATAL 
     $FILE_LOG.fatal(msg) 
    elsif level == :DEBUG 
     $FILE_LOG.debug(msg) 
    end 
    end 
end 

Dann in jede Methode jeder Ruby-Datei, wir diese Protokollierung können als

Logging.log("Message",:FATAL) 

folgt