अपने लॉग्स को एक अपठनीय मेस बनने से रोकें

जब आप एक अजीब, प्रतीत होता है कि असफल बग में भाग लेते हैं, तो अपने लॉगिंग में सुधार करना आपके लिए सबसे अच्छा कदम हो सकता है। महान लॉगिंग बगों की संपूर्ण कक्षाओं का पता लगाने और उन्हें ठीक करने का सबसे आसान तरीका है। जब आप पर्याप्त जानकारी लॉग करते हैं, तो आप देख सकते हैं कि अनुरोध के दौरान आपका डेटा कैसे बदलता है। आप अन्य सेवाओं के लिए किए गए कॉल को ट्रैक कर सकते हैं, और प्रतिक्रिया की जांच कर सकते हैं। वास्तव में, जब डिबगर्स विफल हो गए, तो लॉगिंग ने मुझे अब तक की सबसे कठिन बग को ठीक करने में मदद की।

लेकिन बहुत अधिक लॉग करें, और आपकी लॉग फ़ाइलें शीघ्रता से अपठनीय, अनुपयोगी संदेशों की गड़गड़ाहट में बदल जाएंगी। आप डेटा के उस ढेर में से केवल अपने लिए महत्वपूर्ण जानकारी को कैसे काट सकते हैं? क्या आप संदेशों को इस तरह से प्रिंट कर सकते हैं जिसे बाद में फ़िल्टर करना आसान हो?

अपने लॉग संदेशों को चिह्नित करना

रेल में टैग की गई लॉगिंग शामिल है, जो संबंधित लॉग संदेशों को त्वरित रूप से वर्गीकृत करने में आपकी सहायता कर सकती है। जब आप किसी लकड़हारे को टैग करते हैं, तो आपको अपने संदेश की शुरुआत में एक मार्कर मिलेगा। तो इसके बजाय:

Finding people...
  Person Load (0.3ms)  SELECT "people".* FROM "people"
Found 0 people!

आप रेल लॉगर को टैग कर सकते हैं:

logger.tagged("People") do
  logger.debug "Finding people..."
  @people = Person.all
  logger.debug "Found #{@people.length} people!"
end

और आपको कुछ ऐसा दिखाई देगा:

[People] Finding people...
[People]   Person Load (0.3ms)  SELECT "people".* FROM "people"
[People] Found 0 people!

अब, अलग-अलग चीजों की परवाह करने वाले संदेशों को लॉग करें देख अलग।

कुछ टैग किए गए लकड़हारे उदाहरण

जैसे-जैसे आप अधिक बार लॉग इन करते हैं, और अधिक जटिल चीजों को लॉग करते हैं, आप स्वाभाविक रूप से उन क्षेत्रों पर ध्यान देंगे जहां वे टैग आपके संदेशों को स्पष्ट कर देंगे। लेकिन कुछ स्थान हैं जिन्हें मैंने टैग की गई लॉगिंग को विशेष रूप से उपयोगी पाया है। मैं आमतौर पर उन्हें तुरंत टैग कर दूंगा।

आप अपने द्वारा किए गए अनुरोधों को अन्य API से लॉग कर सकते हैं:

logger.tagged("GitHub API") do
  uri = URI("https://api.github.com/repos/rails/rails/tags")

  logger.info { "Fetching #{uri}" }
  tags = JSON.parse(Net::HTTP.get(uri))
  logger.info { "First tag: #{tags.first["name"]}" }
end

[GitHub API] Fetching https://api.github.com/repos/rails/rails/tags
[GitHub API] First tag: v4.2.4.rc1

इस तरह, आप आसानी से देख सकते हैं कि आपका ऐप उस एपीआई से कैसे और कब बात कर रहा है।

(यह फैराडे मिडलवेयर के साथ विशेष रूप से अच्छी तरह से काम करता है, या यदि आप केवल गेटवे के माध्यम से सर्वर से संवाद करते हैं)।

टैग की गई लॉगिंग के साथ पृष्ठभूमि नौकरियां भी अच्छी तरह से काम करती हैं:

require "active_support/tagged_logging"

Resque.logger = ActiveSupport::TaggedLogging.new(Resque.logger)

module LoggedJob
  def around_perform_log_job(*args)
    logger.tagged(name) do
      logger.info { "Performing #{name} with #{args.inspect}" }
      yield
    end
  end
end

class MyJob
  extend LoggedJob

  def self.perform(*args)
    ...
  end
end

अब, कोई भी कार्य जो LoggedJob का विस्तार करता है, उसके सभी लॉग संदेशों को कार्य के वर्ग नाम के साथ टैग किया जाएगा।

और यदि आपके पास लॉग-इन उपयोगकर्ता है, तो आप संदेशों को उनकी उपयोगकर्ता आईडी से टैग कर सकते हैं:

logger.tagged(current_user_id ? "user-#{current_user_id}" : "user-anonymous") do
  logger.debug "Finding people..."
  @people = Person.all
  logger.debug "Found #{@people.length} people!"
end

[user-123] Finding people...
[user-123]   Person Load (0.3ms)  SELECT "people".* FROM "people"
[user-123] Found 0 people!

आखिरकार, अगर आप अपने config/environments/production.rb में एक लाइन जोड़ते हैं (या development.rb ), आप रेल को अपने संदेशों को स्वचालित रूप से टैग करने के लिए कह सकते हैं:

config.log_tags = [ :subdomain, :uuid ]

log_tags उन टैगों को सूचीबद्ध करता है जिन्हें आप प्रत्येक रेल लॉग प्रविष्टि की शुरुआत में दिखाना चाहते हैं। प्रत्येक प्रतीक ActionDispatch::Request पर एक विधि को संदर्भित करता है, इसलिए :uuid मतलब request.uuid ।

आप एक प्रक्रिया भी पास कर सकते हैं जो एक request . लेता है वस्तु:

config.log_tags = [ :subdomain, :uuid, lambda { |request| request.headers["User-Agent"] } ]

लेकिन मैं ऐसा अक्सर नहीं देखता।

ये डिफ़ॉल्ट टैग अच्छे हैं:uuid एक अनुरोध में होने वाली सभी लॉग प्रविष्टियों को एक साथ जोड़ सकते हैं, और यदि आप सर्वर पर सत्र रख रहे हैं, तो सत्र आईडी भी सहायक है। उन टैगों और पर्याप्त संदेशों के साथ, आप अपने ऐप के माध्यम से वास्तव में कुछ जटिल रास्तों का पता लगा सकते हैं। और आमतौर पर, यह पता लगाने के लिए कि एक बुरा बग कैसे हुआ।

आप अपने ऐप्स में रेल लॉगर का कितना उपयोग करते हैं? क्या आपने टैग की गई लॉगिंग की कोशिश की है? यदि आपने नहीं किया है, तो इसके लिए जगह खोजने का प्रयास करें। आपके उपयोगकर्ताओं द्वारा की गई टैगिंग कार्रवाइयां एक अच्छी शुरुआत है। अगली बार जब आपको किसी पागल बहु-चरणीय बग को डीबग करना होगा तो यह आपकी मदद करेगा।

यदि आप लॉगिंग और अन्य डिबगिंग तकनीकों के बारे में अधिक जानना चाहते हैं, तो मैंने अभ्यास रेल का एक पूरा अध्याय उन त्रुटियों को खोजने और ठीक करने के लिए समर्पित किया है जो आपके द्वारा अपने ऐप बनाते समय चलेंगे। पहले अध्याय को यहां निःशुल्क प्राप्त करें।