Mastering Ruby Debugging: From puts to Professional Tools

Hello Ruby developers!

Debugging is an essential skill in software development, and in this article, we’ll look at how to study the behavior of Ruby code. As the RubyMine team, we’ve developed considerable expertise in creating tools for Ruby developers, and we’re excited to share our experience and knowledge with you.

Recently, at the EuRuKo 2024 conference, our team member Dmitry Pogrebnoy presented Demystifying the Debugger Speech. This blog post is the first in a series based on this briefing and is designed to provide you with valuable insights into debugging Ruby applications.

Every Ruby programmer will inevitably encounter situations where their code does not behave as expected. In these moments, we all want an efficient way to identify the problem and resolve it quickly. This is where debugging tools come into play.

In this article, we’ll explore the various tools and methods that Ruby developers can use to investigate errors. We’ll cover several categories of tools, each with its own advantages and disadvantages. Understanding the specifics of each tool will help you choose the most effective tool for your specific debugging scenario.

To make our discussion more concrete, we’ll start with a real-life example of a bug we encountered in one of our internal Ruby projects. This case study will illustrate the importance of proper debugging techniques and lay the foundation for our exploration of debugging tools.

Whether you’re an experienced Ruby developer or new to Ruby, this guide will help you improve your debugging skills and resolve errors more effectively. Let’s get started!

Real-life error stories from the RubyMine team

On the RubyMine team, our development efforts extend beyond the IDE itself. We have created several proprietary gems to enhance the functionality of the IDE. To share some insight, we’ll explore a real-world bug we encountered in one of our gems about a year ago. We’ve isolated and simplified the code examples to focus on the core issues.

Consider the following Ruby code:

def process(thing)
 if defined? thing.to_s || defined? thing.inspect
   puts "Element is Printable"
 else
   puts "Element is Not Printable"
 end
end

process(5)               # -> Element is Printable
process(BasicObject.new) # -> Element is Printable

At first glance, this process The method seems simple. Its purpose is to check whether the given parameters have to_s or a inspect method. If either method exists, process It should print “Element is Printable”; otherwise, it will print “Element is Not Printable”.

At the bottom you can see the two calls to this method and their output. first call process(5) Generates the message “Element is printable”. that’s right. But the second call process(BasicObject.new) Looks suspicious. it takes BasicObject as a parameter, but prints “Element is Printable”. This is incorrect because BasicObject The instance does not respond to any of the methods we are looking for. Apparently this code contains a bug.

Let’s take a moment to check it out process method. Can you spot this error?

defined?(thing.to_s || defined?(thing.inspect))

def process(thing)
 if defined?(thing.to_s) || defined?(thing.inspect)
   puts "Element is Printable"
 else
   puts "Element is Not Printable"
 end
end

process(5)               # -> Element is Printable
process(BasicObject.new) # -> Element is Not Printable

By sharing this real-life example, we hope to demonstrate that debugging is a vital skill for all developers, regardless of experience level. It’s not just about fixing bugs; it’s about understanding the intricacies of the language and writing more reliable code.

In more complex production-grade applications, identifying and resolving such issues can be more challenging. This emphasizes the importance of powerful debugging tools and techniques, which we explore in the following sections.

Choose the right tool

When debugging Ruby code, developers can use a variety of tools and methods. Let’s explore the options, starting with the basics and then moving on to more advanced techniques.

make a statement

The most basic debugging technique, which requires no setup or additional gems, is to use puts statement. This method involves inserting print statements directly into the program code to output variable values ​​or execution flow information. Although simple, it is very effective for quick investigations.

Let’s apply this technique to the previous example:

def process(thing)
 puts "defined? thing.to_s: #
   defined? thing.to_s "
 puts "defined? thing.inspect: # defined? thing.inspect
 "
 puts "defined? thing.to_s || defined? thing.inspect: # defined? thing.inspect
 "
 if defined? thing.to_s || defined? thing.inspect
   puts "Element is Printable"
 else
   puts "Element is Not Printable"
 end
end

process(5)
process(BasicObject.new)

This produces the following output:

defined? thing.to_s: method
defined? thing.inspect: method
defined? thing.to_s || defined? thing.inspect: expression
Element is Printable
defined? thing.to_s: 
defined? thing.inspect: 
defined? thing.to_s || defined? thing.inspect: expression
Element is Printable

Inconsistent output from calling these two methods with different parameters hints at where the problem may lie. We can see that for BasicObject.newboth thing.to_s and thing.inspect is not defined, but the condition still evaluates to true.

Although basic puts Statements are useful, and some gems can make them more informative:

1. puts_debuggerer Gem enhancement puts The output contains the file name, line number, and the contents of the line.

For example:

require 'puts_debuggerer'
pd "defined? thing.to_s: #{defined? thing.to_s}"

Output:

[PD] example_puts_debuggerer.rb:5 in Object.process
   > pd "defined? thing.to_s: #{defined? thing.to_s}"
  => "Debug print 1: method"

2. awesome_print Similar gems provide more structured and readable output, especially useful for complex objects.

Generally speaking puts Statements are useful and can effectively help you deal with simple situations or when other tools are not working for some reason. However, puts The presentation is really basic. Each time you need to adjust an existing message or add a new message, they require modifications to your source code. They are often inconvenient to use because they require a program restart every time a print content is modified.

Advantages and Disadvantages of Using Debugging puts

advantage:

• Implementation is simple and fast.
• Works in any Ruby environment.
• No additional tools or settings are required.

shortcoming:

• The source code needs to be modified.
• If overused, it can clutter your code.
• If you want to change what is printed, you are forced to restart the program.
• Information is limited compared to more advanced tools.

although puts Statements are valuable for quick inspections, but they become less efficient for complex scenarios or when frequent changes are required. In this case, more advanced tools such as an interactive console or a full-blown debugger provide greater flexibility and functionality.

interactive console

The interactive console represents a new level of bug investigation tools for Ruby developers. The two main options are IRB and pryall provide powerful introspection functions.

To debug using the interactive console, you typically insert binding.irb or binding.pry Call your source code. When a bind command is executed, an interactive console is launched, providing access to the current context and the ability to execute arbitrary expressions within this context.

Let’s use IRB in the previous example:

def process(thing)
 binding.irb
 if defined? thing.to_s || defined? thing.inspect
   puts "Element is Printable"
 else
   puts "Element is Not Printable"
 end
end

process(5) # -> Element is Printable
process(BasicObject.new) # -> Element is Printable

When the code clicks binding.irb OK, we’ll enter an interactive session:

From: 5_example_define_irb.rb @ line 2 :

    1: def process(thing)
 => 2:   binding.irb
    3:   if defined? thing.to_s || defined? thing.inspect
    4:     puts "Element is Printable"
    5:   else
    6:     puts "Element is Not Printable"
    7:   end

irb(main):001> defined? thing.to_s
=> nil
irb(main):002> defined? thing.inspect
=> nil
irb(main):003> defined? thing.to_s || defined? thing.inspect
=> "expression"
irb(main):004> exit
Element is Printable

This interaction allows us to examine the behavior of various parts of the condition, helping to identify problems.

Advantages and disadvantages of using the interactive console for debugging

advantage:

• More complex and flexible than puts statement.
• Some allow instant investigation.
• There is no need to predetermine all debug output.

shortcoming:

• Still need to modify the source code.
• Requires you to set a predefined introspection point that cannot be changed at execution time.
• If you want to change the introspection point, you are forced to restart the program.

While interactive consoles offer more functionality than simple consoles puts statements, they still have limitations. For complex debugging scenarios or when fine-grained control of execution is required, a full-featured debugger provides even more functionality.

debugger

Debuggers represent the top tools available for investigating errors in Ruby code. They offer functionality that goes far beyond simple puts Statements and interactive console provide complete control over program execution. This powerful feature set enables developers to:

• Use breakpoints to pause execution at a specified point.
• Check and modify variables on the fly.
• Check the call stacking at each breakpoint.
• Step through the code line by line.
• Evaluates the expression in the current context.

Let’s explore the three main debuggers for Ruby:

1. byebug gem

• Default debugger for Ruby 2.5.X, Ruby 2.6.X, Rails 5 and Rails 6.
• Comes with all the basic features you would expect from a debugger, such as breakpoints, single-stepping, context, and stacked introspection.
• For Rails applications, the application source code needs to be modified. You usually need to make a special call in your code to start the debugger somewhere.
• There is a significant performance overhead, making it less suitable for complex applications.

2. debug gem

• Only Ruby versions starting from 2.7 are supported.
• There is no performance overhead on supported Ruby versions.
• For Rails applications, debug,similar byebugthe application source code needs to be modified.
• Bundled with Ruby starting with version 3.1.

3. RubyMine debugging tool

• Supports Ruby 2.3 and higher – so your application can work with almost every possible Ruby version.
• There is no performance overhead on any supported Ruby version.
• No code modification is required to use the debugger.
• Provides a user-friendly UI out of the box to simplify debugging.

Although the debugger has an extensive feature set, it can be difficult to use in some specific configurations. Although debuggers are powerful, they are most effective when used in conjunction with other debugging techniques. The choice of debugger often depends on your specific project and configuration requirements, Ruby version, and personal preference.

in conclusion

Debugging in Ruby is both an art and a science, presenting challenges that can be overcome with the right tools. As we explore in this article, Ruby developers have a rich toolkit at their disposal, ranging from simple puts Complex debugger statements.

Each of the debugging methods we discuss has its advantages:

• puts Reports provide quick, direct insights that are ideal for solving simple problems or when other tools are not available.
• Interactive consoles such as IRB and Pry provide a more dynamic environment, allowing deep contextual introspection and complex expression evaluation.
• A full-fledged debugger such as byebug and debug gems and the RubyMine debugger provide complete control over program execution, allowing developers to analyze the most complex errors.

The journey from encountering an unexpected error to figuring out its exact cause often requires a combination of these tools, along with systematic investigation and sometimes some creative problem solving. By understanding the strengths and limitations of each debugging tool, you can choose the most appropriate method for each unique situation.

As the RubyMine team, we are particularly interested in how our debugging tools can serve the Ruby community. We encourage you to explore the RubyMine debugger and share your experiences in the comments below or at Issue tracker. Your fellow developers will appreciate your insights.

Looking ahead, our next article will dive deeper into the inner workings of the debugger. We’ll explore their inner workings and even tackle an exciting challenge: creating a basic debugger from scratch. This exploration will enhance your understanding of debugging tools and provide deeper insight into Ruby’s internals.

Also, take advantage of the high-level debugger in RubyMine. download Get the latest RubyMine version for free from our website or via Toolbox App.

Remember, effective debugging isn’t just about finding and fixing bugs, it’s about fundamentally understanding your code. Every debugging session is an opportunity to learn, improve, and write more robust Ruby code.

Stay curious, keep exploring, and happy debugging!

RubyMine Team