Recently Mike Perham shared a tweet with this comment and a code sample on the Ruby 3.0 Ractors.
If this code doesn't work, how could Rails ever work? Ractor seems fundamentally incompatible with many heavily-used Rails APIs.
require 'logger' class Rails def self.logger @logger ||= Logger.new(STDOUT) end end Ractor.new do Rails.logger.info "Hello" end.take
During the weekend I've added support of Ractors in the Diffend.io, a free platform for an OSS supply chain security and management for Ruby and Rails, so I’m relatively fresh with the topic. Mike’s code illustrates one of the issues developers will face when making their code Ractors compatible.
When you try to run it, you will end up with an exception:
terminated with exception (report_on_exception is true): `take': thrown by remote Ractor. (Ractor::RemoteError) `logger': can not access instance variables of classes/modules from non-main Ractors (RuntimeError)
Is there any way to preserve the Rails#logger
API and allow it to be used from any Ractor we want?
There is!
So, let's start by explaining why this code cannot work:
def self.logger @logger ||= Logger.new(STDOUT) end
There are actually 2 problems with this code, though only one is visible immediately:
- You cannot access instance variables of the shareable objects from Ractors other than the main one.
- You cannot access STDOUT from the non-main Ractor (at least not that way).
The good news is said between the lines: while we cannot use shareable objects and cannot refer to instance variables, we can preserve the Rails.logger
API!
class Rails def self.logger rand end end Ractor.new do Rails.logger end.take.then { p _1 } #=> 0.06450369439220172
But we want to share a logger, right? Well, not exactly. What we want is to be able to use the same API to log pieces of information. And that's the key point here.
We can bypass all of our problems quickly. We just need a separate Ractor that will run all the logging for our application with a standard logger compatible API.
What do we need to achieve this? Not much. We need to:
- Create a Ractor that will have the one and only application wide logger.
- Create API for logging.
- Connect the Ractor to the
Rails#logger
interface.
It all can be achieved with a few lines of code:
class Rogger < Ractor def self.new super do # STDOUT cannot be referenced but $stdout can logger = ::Logger.new($stdout) # Run the requested operations on our logger instance while data = recv logger.public_send(data[0], *data[1]) end end end # Really cheap logger API :) def method_missing(m, *args, &_block) self << [m, *args] end end class Rails LOGGER = Rogger.new def self.logger LOGGER end end Ractor.new do Rails.logger.info "Hello" end
and when we run it, we end up with a different challenge:
terminated with exception (report_on_exception is true): ruby/3.0.0/logger/formatter.rb:15:in `call': can not access global variables $$ from non-main Ractors (RuntimeError) from ruby/3.0.0/logger.rb:586:in `format_message' from ruby/3.0.0/logger.rb:476:in `add' from ruby/3.0.0/logger.rb:529:in `info' from test.rb:23:in `public_send' from test.rb:23:in `block in new'
UPDATE: The pull request that I'm talking about below has been merged, so this monkey patch is no longer needed.
It turns out, the Ruby defaulf logging formatter is not Ractor-friendly. I've opened the pull request to fix this, so once that's merged, the basic Ruby logger formatter will work just fine. For the time being, we will monkey patch it:
class Logger::Formatter def call(severity, time, progname, msg) Format % [ severity[0..0], format_datetime(time), Process.pid, severity, progname, msg2str(msg) ] end end
With this, we can run our logging from any ractor we want:
require 'logger' class Logger::Formatter def call(severity, time, progname, msg) Format % [ severity[0..0], format_datetime(time), Process.pid, severity, progname, msg2str(msg) ] end end class Rogger < Ractor def self.new super do logger = ::Logger.new($stdout) while data = recv logger.public_send(data[0], *data[1]) end end end def method_missing(m, *args, &_block) self << [m, *args] end end class Rails LOGGER = Rogger.new def self.logger LOGGER end end Ractor.new do Rails.logger.info "Hello" end sleep(1)
ruby test.rb I, [2020-09-28T18:23:56.181512 #11519] INFO -- : Hello
Summary
Providing the Ractor support in the things like Rails won't be easy. There are many challenges to tackle, but at the same time, I see it as an excellent opportunity to leverage new Ruby capabilities. It's also a great chance to get away from anti-patterns that are in Ruby and Rails for as long as I can remember. There's a whole new world of engineering that will be much easier to achieve thanks to Ractors.
This year, I want to also explore the possibility of running homogenous Docker containers with Ruby VM in which I could load balance services running in particular guilds. Theoretically, this could allow for sub-second mitigation of sudden traffic spikes without having many overprovisioned instances.
Cover photo by David Stanley on Attribution 2.0 Generic (CC BY 2.0) license.
Leave a Reply