Ruby articles

Brought to you by Honeybadger—simple application monitoring that helps developers move fast and fix things.

 

When to use freeze and frozen? in Ruby

These days it's pretty common to see #freeze used in Ruby code. But it's often not entirely clear WHY freeze is being used. In this post we'll look at the most common reasons a developer might freeze variables.

How to exit a Ruby program

If you want your app to behave well in a unix environment, it's important that it exit correctly. In this post you'll learn all about unix exit codes, the mechanism that Ruby uses to exit a program, and how you can add custom behavior on exit.

Avoid these traps when nesting Ruby modules

But buried within Ruby's nesting implementation - and Rails' autoload system - are a few traps that can cause your code to fail in strange and wonderful ways. In this post, we'll discuss the origin of these traps and how you can avoid them.

Working with Ruby exceptions outside of the rescue block

It's often useful to be able to get the most recent exception, even if your code doesn't control the lifecycle of that exception. In this post we explore a few of the ways to do this.

Mixing code and data in Ruby with DATA and __END__

Did you know that Ruby provides a way for your script to use its own source file as a source of data? It's a neat trick that can save you some time when writing one-off scripts and proofs of concept. Let's check it out!

Associative arrays in Ruby...what?

Have you ever had a bunch of data in an array, but needed to do a key/value lookup like you would with a hash? Fortunately, Ruby provides a mechanism for treating arrays as key-value structures. Let's check it out!

Using lazy enumerators to work with large files in Ruby

Files are just large collections of lines or characters. Lazy enumerators make it possible to to some very interesting and powerful things with them.

Benchmarking exceptions in Ruby - yep, they're slow.

Just how much slower are exceptions than other flow control mechanisms? In this post we use a simple benchmark to find out.

How to raise any object as a Ruby exception

It's a common misconception that the raise method only accepts exceptions as its argument. This post will show you how you can raise ANYTHING, including numbers, dates, and your own custom classes.

How Rails' fancy exception page works

One of the nice things about working with rails is that when something goes wrong in development, you get a really nice error detail page. Today we're going to take a look at how these fancy error pages work.

How to clear all Sidekiq queues, using the power of emoji

It’s easy to find code snippets that will delete the jobs from one Sidekiq queue. But we have lots of queues. I want to clear the jobs from all of them. After a little digging, I came up with an answer that seems to work well.

Use any C library from Ruby via Fiddle - the Ruby standard library's best kept secret.

Fiddle is a little-known module that was added to Ruby's standard library in 1.9.x. It allow you to interact directly with C libraries from Ruby. In this post we'll start with some simple examples and finish by using termios to talk to an arduino over a serial port.

How to add context data to exceptions in Ruby

Sometimes the standard backtrace / error message combo isn't enough. Sometimes you need extra data to locate the cause of an error. In this post we'll discuss three easy ways to add more context to your exceptions.

Understanding Ruby's strange "Errno" exceptions

If you've ever taken a look at Ruby's exception hierarchy, you may have noticed something weird. In addition to all of the normal exceptions like RuntimeError and NoMethodError, there's an odd reference to Errno::* . This post discusses what these exceptions are and how to interpret them.

A theoretical introduction to unix daemons in Ruby

Unix daemons are programs that run in the background. Nginx, Postgres and OpenSSH are a few examples. They use a some special tricks to “detatch” their processes, and let them run independently of any terminal. I thought it’d be fun to do a post illustrating how they work in Ruby.

Logging local & instance variables when exceptions occur in Ruby

With hard-to-reproduce bugs, it can be really handy to log all of the local and instance variables along with the exception. This post shows you how. Along the way we'll introduce Ruby's binding system as well as the bindingofcaller gem - a powerful tool for introspection.

Remote debugging with Byebug, Rails and Pow

Byebug is a simple to use, feature rich debugger for Ruby 2.x. In this post, we'll discuss how to set up remote debugging with byebug so that you can debug code running in Pow, Unicorn or other application servers.

Ruby's case statement - advanced techniques

Nothing could be simpler and more boring than the case statement. It’s a holdover from C. You use it to replace a bunch of ifs. Case closed. Or is it? Actually, case statements in Ruby are a lot richer and more complex than you might imagine. Let’s take a look.

How unicorn talks to nginx - an introduction to unix sockets in Ruby

In this post we start out with the basics of unix sockets and finish by creating our own simple Ruby application server which can be proxied by nginx.

Level-up `rescue` with dynamic exception matchers

When you use a rescue clause in Ruby, you can specify what kinds of exceptions you want to rescue. But what if you want to rescue exceptions by severity? By message? By time of day? In this post we'll discuss how you can create dynamic exception matchers that use your logic to decide if an exception gets rescued.

Honeybadger's logo: a lightening bolt inside of a diamond shape.
Product
Stacks
Company
Resources
Switching to Honeybadger