एक स्वतंत्र लॉग फ़ाइल में रेल में कुछ कैसे लॉग इन करें?

Question

रेल में मैं एक अलग लॉग फ़ाइल में कुछ जानकारी लॉग इन करना चाहता हूं न कि मानक विकास.लॉग या प्रोडक्शन.लॉग। मैं एक मॉडल वर्ग से यह लॉगिंग करना चाहता हूं।

Answer 1

आप किसी भी मॉडल के अंदर से एक लॉगर ऑब्जेक्ट खुद बना सकते हैं। बस निर्माता को फ़ाइल का नाम दें और सामान्य रेल की तरह ऑब्जेक्ट का उपयोग करें logger:

class User < ActiveRecord::Base
  def my_logger
    @@my_logger ||= Logger.new("#{Rails.root}/log/my.log")
  end

  def before_save
    my_logger.info("Creating user with name #{self.name}")
  end
end

यहाँ मैंने लकड़हारे को याद करने के लिए एक वर्ग विशेषता का उपयोग किया। इस तरह यह हर एक उपयोगकर्ता ऑब्जेक्ट के लिए नहीं बनाया जाएगा जो बनाया जाता है, लेकिन आपको ऐसा करने की आवश्यकता नहीं है। यह भी याद रखें कि आप अपने ऐप के मॉडल के बीच कोड को साझा करने के लिए my_loggerविधि को सीधे ActiveRecord::Baseकक्षा में (या अपने खुद के कुछ सुपरक्लास में बंदर के बहुत ज्यादा पसंद न करने पर) इंजेक्ट कर सकते हैं।

Comments

यदि आप उस विशिष्ट मॉडल के लिए सभी डिफ़ॉल्ट लॉगिंग को बदलना चाहते हैं, तो आप बस User.logger = Logger.new(STDOUT)या जहाँ भी आप लॉग इन करना चाहते हैं, उपयोग कर सकते हैं। उसी तरह, ActiveRecord::Base.logger = Logger.new(STDOUT)सभी मॉडलों के लिए सभी लॉगिंग को बदल देगा।

— डेव

किसी को पता है कि प्रत्येक लॉग में फ़ोल्डर्स कैसे बनाएं?

— मूरो डायस

@ क्या मैंने आपके सुझाव की कोशिश की है और यह विफल रहा। User.logger = Logger.new(STDOUT)सभी मॉडलों के लिए सभी लॉगिंग को बदल दिया। खैर, यह बदल गयाActiveRecord::Base.logger

— fetsh

@ilzoff हां, यह संभव है कि यह व्यवहार 3 साल पहले रेल में बदल गया है। इसे कॉल करने के लिए धन्यवाद।

— डेव

धन्यवाद। my_loggerमें रखने से मेरे नियंत्रकों के लिए बहुत ज्यादा एक ही था application_controller.rb।

— kstratis

Answer 2

अपडेट करें

मैंने नीचे दिए गए समाधान के आधार पर एक मणि बनाया, जिसे मल्टी_लॉगर कहा जाता है । बस इसे इनिशियलाइज़र में करें:

MultiLogger.add_logger('post')

और कॉल करें

Rails.logger.post.error('hi')
# or call logger.post.error('hi') if it is accessible.

और आप कर रहे हैं

यदि आप इसे स्वयं कोड करना चाहते हैं, तो नीचे देखें:

---

एक और पूर्ण समाधान निम्न को अपनी lib/या config/initializers/निर्देशिका में रखना होगा ।

लाभ यह है कि आप फ़ॉर्मेटर को प्रीफ़िक्स टाइमस्टैम्प या लॉग्स में गंभीरता से स्वचालित रूप से सेटअप कर सकते हैं। यह रेल में कहीं से भी पहुंच योग्य है, और सिंगलटन पैटर्न का उपयोग करके नट दिखता है।

# Custom Post logger
require 'singleton'
class PostLogger < Logger
  include Singleton

  def initialize
    super(Rails.root.join('log/post_error.log'))
    self.formatter = formatter()
    self
  end

  # Optional, but good for prefixing timestamps automatically
  def formatter
    Proc.new{|severity, time, progname, msg|
      formatted_severity = sprintf("%-5s",severity.to_s)
      formatted_time = time.strftime("%Y-%m-%d %H:%M:%S")
      "[#{formatted_severity} #{formatted_time} #{$$}] #{msg.to_s.strip}\n"
    }
  end

  class << self
    delegate :error, :debug, :fatal, :info, :warn, :add, :log, :to => :instance
  end
end

PostLogger.error('hi')
# [ERROR 2012-09-12 10:40:15] hi

Comments

किसलिए है #{$$}?

— डेनियल कोस्टा

@DanielCosta stackoverflow.com/questions/2177008/…

— lulalala

Answer 3

एक सभ्य विकल्प जो मेरे लिए काम करता है, वह है कि app/modelsआप अपने फ़ोल्डर में एक सादा वर्ग जोड़ दें जैसे किapp/models/my_log.rb

class MyLog
  def self.debug(message=nil)
    @my_log ||= Logger.new("#{Rails.root}/log/my.log")
    @my_log.debug(message) unless message.nil?
  end
end

फिर अपने नियंत्रक में, या वास्तव में लगभग कहीं भी कि आप अपने रेल एप्लिकेशन के भीतर से मॉडल के वर्ग को संदर्भित कर सकते हैं, यानी कहीं भी आप ऐसा कर सकते हैं Post.create(:title => "Hello world", :contents => "Lorum ipsum");या ऐसा ही कुछ आप अपनी कस्टम फ़ाइल में लॉग इन कर सकते हैं।

MyLog.debug "Hello world"

Comments

स्मार्ट और सरल समाधान!

— अनवर

Answer 4

(कहते हैं) एप्लिकेशन / मॉडल / special_log.rb में एक लकड़हारा वर्ग को परिभाषित करें:

class SpecialLog
  LogFile = Rails.root.join('log', 'special.log')
  class << self
    cattr_accessor :logger
    delegate :debug, :info, :warn, :error, :fatal, :to => :logger
  end
end

लकड़हारा को प्रारंभ करें (कहें) कॉन्‍फ़िगरेशन / इनिशियलाइज़र / special_log.rb:

SpecialLog.logger = Logger.new(SpecialLog::LogFile)
SpecialLog.logger.level = 'debug' # could be debug, info, warn, error or fatal

आपके एप्लिकेशन में कहीं भी, आप इसके साथ लॉग इन कर सकते हैं:

SpecialLog.debug("something went wrong")
# or
SpecialLog.info("life is good")

Answer 5

यहाँ मेरा कस्टम लकड़हारा है:

class DebugLog
  def self.debug(message=nil)
    return unless Rails.env.development? and message.present?
    @logger ||= Logger.new(File.join(Rails.root, 'log', 'debug.log'))
    @logger.debug(message) 
  end
end

Answer 6

class Article < ActiveRecord::Base  

      LOGFILE = File.join(RAILS_ROOT, '/log/', "article_#{RAILS_ENV}.log")  

      def validate  
        log "was validated!"  
      end   

      def log(*args)  
       args.size == 1 ? (message = args; severity = :info) : (severity, message = args)  
       Article.logger severity, "Article##{self.id}: #{message}"  
     end  

     def self.logger(severity = nil, message = nil)  
       @article_logger ||= Article.open_log  
       if !severity.nil? && !message.nil? && @article_logger.respond_to?(severity)  
         @article_logger.send severity, "[#{Time.now.to_s(:db)}] [#{severity.to_s.capitalize}] #{message}\n"  
       end  
       message or @article_logger  
     end  

     def self.open_log  
       ActiveSupport::BufferedLogger.new(LOGFILE)  
     end  

   end  

Answer 7

मैं कस्टम लॉगिंग के लिए Log4r रत्न का उपयोग करने का सुझाव दूंगा । इसके पृष्ठ से उद्धरण का वर्णन:

Log4r रूबी कार्यक्रमों में उपयोग के लिए रूबी में लिखी गई एक व्यापक और लचीली लॉगिंग लाइब्रेरी है। इसमें किसी भी स्तर, कस्टम स्तर के नाम, लॉगर इनहेरिटेंस, कई आउटपुट डेस्टिनेशन प्रति लॉग ईवेंट, निष्पादन अनुरेखण, कस्टम स्वरूपण, थ्रेड सेफटीनेस, XML और YAML कॉन्फ़िगरेशन, और अधिक की एक श्रेणीबद्ध लॉगिंग सिस्टम की सुविधा है।

Answer 8

class Post < ActiveRecord::Base
    def initialize(attributes)
        super(attributes)
        @logger = Logger.new("#{Rails.root}/log/post.log")
    end

    def logger
        @logger
    end

    def some_method
        logger.info('Test 1')
    end
end

ps = Post.new
ps.some_method
ps.logger.info('Test 2')
Post.new.logger.info('Test 3')

Answer 9

लॉगिंग फ्रेमवर्क, इसके भ्रामक सरल नाम के साथ, परिष्कार है जिसे आप तरसते हैं!

शोर को छानने, अलर्ट प्राप्त करने और ठीक-ठाक और उच्च-स्तरीय तरीके से आउटपुट चुनने के लिए लॉगिंग-रेल के बहुत कम निर्देशों का पालन करें ।

जब आप कर रहे हों तो खुद को पीठ पर थपथपाएं। लॉग-रोलिंग, दैनिक। यह अकेले के लिए लायक है।