Module: ObjectSpace

Returns the class for the given object.

class A
  def foo
    ObjectSpace::trace_object_allocations do
      obj = Object.new
      p "#{ObjectSpace::allocation_class_path(obj)}"
    end
  end
end

A.new.foo #=> "Class"

See .trace_object_allocations for more information and examples.

Returns garbage collector generation for the given object.

class B
  include ObjectSpace

  def foo
    trace_object_allocations do
      obj = Object.new
      p "Generation is #{allocation_generation(obj)}"
    end
  end
end

B.new.foo #=> "Generation is 3"

See .trace_object_allocations for more information and examples.

Returns the method identifier for the given object.

class A
  include ObjectSpace

  def foo
    trace_object_allocations do
      obj = Object.new
      p "#{allocation_class_path(obj)}##{allocation_method_id(obj)}"
    end
  end
end

A.new.foo #=> "Class#new"

See .trace_object_allocations for more information and examples.

Returns the source file origin from the given object.

See .trace_object_allocations for more information and examples.

Returns the original line from source for from the given object.

See .trace_object_allocations for more information and examples.

Returns a hash containing the number of objects for each T_IMEMO type. The keys are Symbol objects of the T_IMEMO type name. T_IMEMO objects are Ruby internal objects that are not visible to Ruby programs.

ObjectSpace.count_imemo_objects
# => {imemo_callcache: 5482, imemo_constcache: 1258, imemo_ment: 13906, ... }

If the optional argument result_hash is given, it is overwritten and returned. This is intended to avoid the probe effect.

This method is intended for developers interested in performance and memory usage of Ruby programs. The contents of the returned hash is implementation specific and may change in the future.

This method is only expected to work with C Ruby.

Counts objects size (in bytes) for each type.

Note that the returned size may not be accurate, so it should only be used as a hint. Specifically, the size for T_DATA may be inaccurate because these are custom objects defined in Ruby and native extensions and so they may not accurately report their memory size.

It returns a hash that looks like:

{TOTAL: 1461154, T_CLASS: 158280, T_MODULE: 20672, T_STRING: 527249, ...}

The contents of the returned hash are implementation specific and may be changed in future versions without notice.

If the optional argument, result_hash, is given, it is overwritten and returned. This is intended to avoid the probe effect.

This method is only expected to work with C Ruby.

Returns a hash containing the number of objects for each Symbol type.

The types of Symbols are the following:

• mortal_dynamic_symbol: Symbols that are garbage collectable.
• immortal_dynamic_symbol: Symbols that are objects allocated from the garbage collector, but are not garbage collectable.
• immortal_static_symbol: Symbols that are not allocated from the garbage collector, and are thus not garbage collectable.
• immortal_symbol: the sum of immortal_dynamic_symbol and immortal_static_symbol.

If the optional argument result_hash is given, it is overwritten and returned. This is intended to avoid the probe effect.

This method is intended for developers interested in performance and memory usage of Ruby programs. The contents of the returned hash is implementation specific and may change in the future.

This method is only expected to work with C Ruby.

Returns a hash containing the number of objects for each T_DATA type. The keys are Class objects when the T_DATA object has an associated class, or Symbol objects of the name defined in the rb_data_type_struct for internal T_DATA objects.

ObjectSpace.count_tdata_objects
# => {RBS::Location => 39255, marshal_compat_table: 1, Encoding => 103, mutex: 1, ... }

If the optional argument result_hash is given, it is overwritten and returned. This is intended to avoid the probe effect.

This method is intended for developers interested in performance and memory usage of Ruby programs. The contents of the returned hash is implementation specific and may change in the future.

This method is only expected to work with C Ruby.

Dump the contents of a ruby object as JSON.

output can be one of: :stdout, :file, :string, or IO object.

• :file means dumping to a tempfile and returning corresponding File object;
• :stdout means printing the dump and returning nil;
• :string means returning a string with the dump;
• if an instance of IO object is provided, the output goes there, and the object is returned.

This method is only expected to work with C Ruby. This is an experimental method and is subject to change. In particular, the function signature and output format are not guaranteed to be compatible in future versions of ruby.

Dump the contents of the ruby heap as JSON.

output argument is the same as for #dump.

full must be a boolean. If true, all heap slots are dumped including the empty ones (T_NONE).

since must be a non-negative integer or nil.

If since is a positive integer, only objects of that generation and newer generations are dumped. The current generation can be accessed using GC.count. Objects that were allocated without object allocation tracing enabled are ignored. See .trace_object_allocations for more information and examples.

If since is omitted or is nil, all objects are dumped.

shapes must be a boolean or a non-negative integer.

If shapes is a positive integer, only shapes newer than the provided shape id are dumped. The current shape_id can be accessed using RubyVM.stat(:next_shape_id).

If shapes is false, no shapes are dumped.

To only dump objects allocated past a certain point you can combine since and shapes:

ObjectSpace.trace_object_allocations
GC.start
gc_generation = GC.count
shape_generation = RubyVM.stat(:next_shape_id)
call_method_to_instrument
ObjectSpace.dump_all(since: gc_generation, shapes: shape_generation)

This method is only expected to work with C Ruby. This is an experimental method and is subject to change. In particular, the function signature and output format are not guaranteed to be compatible in future versions of ruby.

Dump the contents of the ruby shape tree as JSON.

output argument is the same as for #dump.

If since is a positive integer, only shapes newer than the provided shape id are dumped. The current shape_id can be accessed using RubyVM.stat(:next_shape_id).

This method is only expected to work with C Ruby. This is an experimental method and is subject to change. In particular, the function signature and output format are not guaranteed to be compatible in future versions of ruby.

Returns the real class of obj, which may differ from the class returned by Object#class.

Ruby inserts hidden classes into an object's ancestry, such as a singleton class or an included module's iclass. Object#class skips over these, but this method returns the first one, including any hidden class:

require 'objspace'

s = "x"
def s.foo; end                     # gives {s} a singleton class
s.class                            # => String
ObjectSpace.internal_class_of(s)   # => #<Class:#<String:0x000000012574c1f8>>

obj may be an ::ObjectSpace::InternalObjectWrapper, in which case the class of the wrapped internal object is returned.

Note that you should not use this method in your application.

This method is only expected to work with C Ruby.

Returns the immediate superclass of cls, including any hidden class such as an included module's iclass.

Unlike Class#superclass, this does not skip over the iclasses that Ruby inserts for included modules:

require 'objspace'

module M; end
class A; include M; end
A.superclass                       # => Object
ObjectSpace.internal_super_of(A)   # => #<InternalObject:0x... T_ICLASS>

cls must be a Class or Module, or an ::ObjectSpace::InternalObjectWrapper that wraps one.

Note that you should not use this method in your application.

This method is only expected to work with C Ruby.

Returns the amount of memory in bytes consumed by obj.

The returned size includes the slot that obj occupies plus any memory that obj allocates outside of that slot, such as the storage backing a large String, Array, or Hash:

require 'objspace'

ObjectSpace.memsize_of("small")        # => 40
ObjectSpace.memsize_of("a" * 1000)     # => 1041
ObjectSpace.memsize_of([1, 2, 3])      # => 40
ObjectSpace.memsize_of(Array.new(100)) # => 840

Special constants such as true, false, nil, small integers, and some symbols do not occupy a slot, so their size is reported as 0:

ObjectSpace.memsize_of(true)   # => 0
ObjectSpace.memsize_of(42)     # => 0

The returned size is only a hint and may be an underestimate, since it does not account for all of the memory that obj references. In particular, the size of a T_DATA object (an object implemented in C, such as one defined by a C extension) may not be reported correctly.

This method is only expected to work with CRuby.

Returns the total memory size of all living objects in bytes.

ObjectSpace.memsize_of_all # => 12502001

If klass is given (which must be a Class or Module), returns the total memory size of objects whose class is, or is a subclass, of klass.

class MyClass; end
ObjectSpace.memsize_of_all(MyClass) # => 0
o = MyClass.new
ObjectSpace.memsize_of_all(MyClass) # => 40

Note that the value returned may be an underestimate of the actual amount of memory used. Therefore, the value returned should only be used as a hint, rather than a source of truth. In particular, the size of T_DATA objects may not be correct.

This method is only expected to work with C Ruby.

Returns all reachable objects from obj as an array:

ObjectSpace.reachable_objects_from(['a', 'b', 'c'])
#=> [Array, 'a', 'b', 'c']

The returned array is deduplicated, meaning that if obj refers to another object more than once, it will only be added to the array once:

ObjectSpace.reachable_objects_from([v = 'a', v, v])
#=> [Array, 'a']

Returns nil if obj is not a markable object (i.e. non-heap managed) object. Non-markable objects include true, false, nil, certain symbols, small integers, and floats:

ObjectSpace.reachable_objects_from(1)
#=> nil

All references to internal objects in the returned array are wrapped using ::ObjectSpace::InternalObjectWrapper objects. This object contains a reference to the internal object and the type of the object can be accessed using the InternalObjectWrapper#type method.

If obj is instance of ::ObjectSpace::InternalObjectWrapper, then this method returns all reachable object from the internal object.

This method is useful for debugging purposes, such as finding memory leaks.

This method is only expected to work with C Ruby.

Returns a hash of objects directly reachable from the VM roots, grouped by the root that reaches them.

The roots are the entry points the garbage collector starts from when it marks live objects, such as the virtual machine and the global variable table. The keys of the returned hash are strings naming each root, and each value is an array of the objects reachable from that root:

require 'objspace'

reachable = ObjectSpace.reachable_objects_from_root
reachable.keys           # => ["vm", "global_tbl", "machine_context", "global_symbols"]
reachable.values.first   # => [#<Ractor:#1 running>, ...]

The returned hash compares its keys by identity, so it cannot be indexed with a string literal; iterate over it (or over its #values) instead.

Any reference to an internal object is wrapped in an ::ObjectSpace::InternalObjectWrapper object.

This method is useful for debugging the object graph, for example when tracking down the cause of a memory leak.

This method is only expected to work with C Ruby.

Starts tracing object allocations from the ObjectSpace extension module.

For example:

require 'objspace'

class C
  include ObjectSpace

  def foo
    trace_object_allocations do
      obj = Object.new
      p "#{allocation_sourcefile(obj)}:#{allocation_sourceline(obj)}"
    end
  end
end

C.new.foo #=> "objtrace.rb:8"

This example has included the ObjectSpace module to make it easier to read, but you can also use the .trace_object_allocations notation (recommended).

Note that this feature introduces a huge performance decrease and huge memory consumption.

Clear recorded tracing information.

Starts tracing object allocations for GC debugging. If you encounter the BUG "... is T_NONE" (and so on) on your application, please try this method at the beginning of your app.

Starts tracing object allocations.

Stop tracing object allocations.

Note that if .trace_object_allocations_start is called n-times, then tracing will stop after calling .trace_object_allocations_stop n-times.