There are some tricky bits to it, though, that do add a layer of complexity.

Take, for example, this:

irb(main):001:0> a = "abc"
=> "abc"

So, byte_size on that would be straightforward to calculate, right?

What happens with this, though:

class << a
def scratch
@scratch
end

def scratch=(val)
@scratch = val
end
end

irb(main):010:0> a.scratch = "def"
=> "def"
irb(main):011:0> a
=> "abc"

Even if String knew how to report on the size of it's slot + allocations, that wouldn't be accurate for the String subclass pointed to by 'a' in that example, because it stores a second String in an instance variable.

To really be accurate the object implementations would have to keep track of their own allocations, as well as be able to interrogate all of their instance variables for their own size.

And then what happens when you get a cycle?

irb(main):004:0> class UtOh < String
irb(main):005:1> attr_accessor :trouble
irb(main):006:1> end
=> nil
irb(main):007:0> a = UtOh.new('abc')
=> "abc"
irb(main):008:0> b = UtOh.new('xyz')
=> "xyz"
irb(main):009:0> a.trouble = b
=> "xyz"
irb(main):010:0> b.trouble = a
=> "abc"
irb(main):011:0> a
=> "abc"
irb(main):012:0> a.trouble
=> "xyz"
irb(main):013:0> a.trouble.trouble
=> "abc"

So, what's the size of the UtOh object pointed to by variable 'a'? You can figure it out in your head, but for code it becomes interestingly non-trivial. Still doable, but not a project that anyone that I am aware of has undertaken.