अपने रूबी तरीकों की जासूसी कैसे करें

रूबी में एक अंतर्निहित अनुरेखण प्रणाली है जिसे आप TracePoint . का उपयोग करके एक्सेस कर सकते हैं कक्षा। कुछ चीज़ें जिन्हें आप ट्रेस कर सकते हैं, वे हैं मेथड कॉल, नए थ्रेड और अपवाद।

आप इसका उपयोग क्यों करना चाहेंगे?

ठीक है, यदि आप किसी निश्चित विधि के निष्पादन का पता लगाना चाहते हैं तो यह उपयोगी हो सकता है। आप देख पाएंगे कि अन्य विधियों को क्या कहा जा रहा है और वापसी मूल्य क्या हैं।

आइए कुछ उदाहरण देखें!

ट्रेसिंग मेथड कॉल्स

अधिकतर समय आप TracePoint चाहते हैं एप्लिकेशन कोड का पता लगाने के लिए और अंतर्निहित विधियों (जैसे पुट, आकार, आदि) को नहीं।

आप call . का उपयोग करके ऐसा कर सकते हैं घटना।

उदाहरण :

def the_method; other_method; end
def other_method; end

def start_trace
  trace =
  TracePoint.new(:call) { |tp| p [tp.path, tp.lineno, tp.event, tp.method_id] }

  trace.enable
  yield
  trace.disable
end

start_trace { the_method }

यह फ़ाइल पथ, पंक्ति संख्या, घटना का नाम और विधि का नाम प्रिंट करता है।

["test.rb", 1, :call, :the_method]
["test.rb", 2, :call, :other_method]

यदि आप कोई ईवेंट निर्दिष्ट नहीं करते हैं, तो रूबी उन सभी के लिए आपके ब्लॉक को कॉल करेगी, जिसके परिणामस्वरूप अधिक आउटपुट होगा। इसलिए मैं अनुशंसा करता हूं कि आप विशिष्ट घटनाओं पर ध्यान केंद्रित करें ताकि आप जो चाहते हैं उसे तेज़ी से ढूंढ सकें 🙂

यहाँ TracePoint की एक तालिका है इवेंट:

ट्रेसपॉइंट + ग्राफविज़

कई विधियाँ केवल 3 विधियों से अधिक कॉल करेंगी, विशेष रूप से फ्रेमवर्क कोड में, इसलिए Tracepoint से आउटपुट कल्पना करना कठिन हो सकता है।

इसलिए मैंने एक ऐसा रत्न बनाया है जिससे आप इस तरह से एक विज़ुअल कॉल ग्राफ़ बना सकते हैं:

require 'visual_call_graph'

VisualCallGraph.trace { "Your method call here..." }

यह एक call_graph.png उत्पन्न करता है परिणामों के साथ फाइल करें।

ध्यान रखें कि यह स्थैतिक विश्लेषण नहीं है, यह वास्तव में विधि कहलाएगा!

फ़ाइल पथ दिखा रहा है

क्या आप जानना चाहेंगे कि इन विधियों को कहाँ परिभाषित किया गया है?

चिंता मत करो, मैंने तुम्हें कवर कर लिया है! मैंने एक विकल्प जोड़ा है जिसे आप प्रत्येक विधि कॉल के लिए फ़ाइल पथ दिखाने के लिए सक्षम कर सकते हैं।

VisualCallGraph.trace(show_path: true) { Foo.aaa }

जिसका परिणाम होता है :

यदि आप कुछ बड़े कॉल ग्राफ़ देखना चाहते हैं तो आपको बस कुछ रेल विधियों का पता लगाना होगा 😉

रिटर्न वैल्यू

परिचय में मैंने उल्लेख किया है कि आप वापसी मूल्य भी प्राप्त कर सकते हैं…

इसके लिए आपको return . को ट्रेस करना होगा ईवेंट और return_value . का उपयोग करें विधि।

उदाहरण :

def the_method; "A" * 10; end

trace = TracePoint.new(:return) { |tp| puts "Return value for #{tp.method_id} is #{tp.return_value}." }

trace.enable
the_method
trace.disable

यह प्रिंट होगा:

Return value for the_method is AAAAAAAAAA.

पहले इवेंट

किसी ने reddit पर पूछा कि foo पर कॉल करते समय "बार" शब्द के प्रिंट होने से कैसे बचा जा सकता है? निम्नलिखित कोड में विधि:

class Thing
  def foo
    puts "foo"
    bar
  end

  def bar
    puts "bar"
  end
end

# your code here

t = Thing.new
t.foo

इसे प्राप्त करने के कई तरीके हैं, जैसे किसी मॉड्यूल को तैयार करना, $stdout . को पुनर्निर्देशित करना या bar को फिर से परिभाषित करना विधि।

यदि आप रचनात्मक महसूस कर रहे हैं, तो इस पोस्ट पर अपने विचार के साथ टिप्पणी करें!

लेकिन मुझे इनमें से एक उत्तर विशेष रूप से दिलचस्प लगा क्योंकि इसमें TracePoint . का उपयोग किया गया था कक्षा।

यह रहा :

TracePoint.trace(:call) { |tp| exit if tp.method_id == :bar }

यह कोड exit . को कॉल करेगा जब विधि bar कहा जाता है, जो प्रोग्राम को समाप्त करके स्ट्रिंग को प्रिंट होने से रोकता है।

शायद ऐसा कुछ नहीं जिसे आप वास्तविक कोड में उपयोग करना चाहते हैं, लेकिन यह TracePoint . के बारे में एक बात साबित करता है :ईवेंट होने से पहले ही ट्रिगर हो जाते हैं।

अगर आप इसके इर्द-गिर्द किसी प्रकार का टूल बनाने जा रहे हैं तो कुछ बातों का ध्यान रखें

सारांश

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

इस पोस्ट को साझा करना . याद रखें ताकि अधिक से अधिक लोग इसका आनंद उठा सकें 🙂