rbkit 0.0.1 → 0.1.6

data/experiments/object_dump.rb

@@ -3,7 +3,7 @@ $:<< File.join(File.dirname(__FILE__), "../ext")
 
 require 'rbkit'
 
-Rbkit.start_profiling(5555)
+Rbkit.start_profiling
 
 class Foo
   def initialize(name)

data/experiments/rbkit_command_test.rb

@@ -9,7 +9,8 @@ commands = [
   'start_memory_profile',
   'stop_memory_profile',
   'objectspace_snapshot',
-  'trigger_gc'
+  'trigger_gc',
+  'handshake'
 ]
 
 output_file = File.open("/tmp/rbkit.log", "w")
@@ -33,6 +34,7 @@ Thread.new do
       request_socket.send(command)
       puts "sent #{command}"
       response = request_socket.recv()
+      response = MessagePack.unpack(response) unless response == "ok"
       puts "received #{response}"
     end
   end

data/experiments/using_rbkit.rb

@@ -3,7 +3,7 @@ $:<< File.join(File.dirname(__FILE__), "../ext")
 
 require 'rbkit'
 
-Rbkit.start_profiling(5555)
+Rbkit.start_profiling
 
 class Foo
   def initialize(name)

data/ext/extconf.rb

@@ -1,18 +1,101 @@
 require 'mkmf'
+require 'fileutils'
+
+CWD = File.expand_path('../', __FILE__)
+
+def red(str);   "\033[31m#{str}\033[0m" end
+def green(str); "\033[32m#{str}\033[0m" end
+
 if ENV['RBKIT_DEV']
-  $stderr.puts "Dev environment enabled."
-  $CFLAGS << ' -g'
-  $defs << '-DRBKIT_DEV'
+  puts green("Dev environment enabled.")
+  $CFLAGS << ' -g' # Enable debug flag
+  $defs << '-DRBKIT_DEV' # Set macro named RBKIT_DEV
 end
-if(have_func('rb_postponed_job_register_one') &&
+
+def download_file(url)
+  if find_executable('curl')
+    system("curl -L -O #{url}")
+  elsif find_executable('wget')
+    system("wget #{url}")
+  else
+    fail "Cannot download #{url}. You need either curl or wget to continue"
+  end
+end
+
+def download_and_install_zeromq_from_source
+  url = "http://download.zeromq.org/zeromq-4.0.4.tar.gz"
+  filename = "zeromq-4.0.4.tar.gz"
+  basename = File.basename(filename, '.tar.gz')
+  dist_path = "#{CWD}/#{basename}/dist"
+
+  unless File.exists? "#{dist_path}/lib/libzmq.a"
+    ['libtool', 'autoconf', 'automake'].each do |executable|
+      fail "#{executable} needed by zeromq not found." unless find_executable(executable)
+    end
+    puts green("Downloading and installing zeromq from source")
+    download_file(url)
+    system("tar zxvf #{filename}")
+    Dir.chdir(basename) do
+      system("./configure CPPFLAGS='-fPIC' --prefix='#{dist_path}'")
+      system("make && make install")
+    end
+  end
+  FileUtils.cp "#{dist_path}/lib/libzmq.a", "#{CWD}/libzmq.a"
+  $INCFLAGS[0,0] = "-I#{dist_path}/include "
+end
+
+def download_and_install_msgpack_from_source
+  url = "https://github.com/msgpack/msgpack-c/releases/download/cpp-0.5.9/msgpack-0.5.9.tar.gz"
+  filename = "msgpack-0.5.9.tar.gz"
+  basename = File.basename(filename, '.tar.gz')
+  dist_path = "#{CWD}/#{basename}/dist"
+
+  unless File.exists? "#{dist_path}/lib/libmsgpack.a"
+    puts green("Downloading and installing msgpack from source")
+    download_file(url)
+    system("tar zxvf #{filename}")
+    Dir.chdir(basename) do
+      system("./configure CFLAGS='-fPIC' --prefix='#{dist_path}'")
+      system("make && make install")
+    end
+  end
+
+  FileUtils.cp "#{dist_path}/lib/libmsgpack.a", "#{CWD}/libmsgpack.a"
+  $INCFLAGS[0,0] = "-I#{dist_path}/include "
+end
+
+# Ensure Ruby 2.1.x API exists before proceeding
+unless(have_func('rb_postponed_job_register_one') &&
   have_func('rb_profile_frames') &&
   have_func('rb_tracepoint_new') &&
-  have_const('RUBY_INTERNAL_EVENT_NEWOBJ') &&
-  have_library("zmq") &&
-  have_header("zmq.h") &&
-  have_library("msgpack") &&
-  have_header("msgpack.h"))
-  create_makefile('rbkit_tracer')
-else
-  fail 'missing API: are you using ruby 2.1+?'
+  have_const('RUBY_INTERNAL_EVENT_NEWOBJ'))
+  fail 'Missing Ruby 2.1.x API. Rbkit only works with Ruby 2.1+'
+end
+
+# Install zmq if not available
+unless(have_library("zmq") && have_header("zmq.h"))
+  if Gem.win_platform?
+    puts red("On Windows? You'll have to install zeromq by yourself.")
+  else
+    download_and_install_zeromq_from_source
+  end
+
+  unless have_library('stdc++') and have_library('zmq') and have_header('zmq.h')
+    fail 'zeromq build failed.'
+  end
+end
+
+# Install msgpack if not available
+unless(have_library("msgpack") && have_header("msgpack.h"))
+  if Gem.win_platform?
+    puts red("On Windows? You'll have to install msgpack by yourself.")
+  else
+    download_and_install_msgpack_from_source
+  end
+
+  unless have_library('msgpack') and have_header('msgpack.h')
+    fail 'msgpack build failed.'
+  end
 end
+
+create_makefile('rbkit_tracer')

data/ext/rbkit_allocation_info.c

@@ -0,0 +1,91 @@
+#include "rbkit_allocation_info.h"
+
+/*
+ * make_unique_str helps to reuse memory by allocating memory for a string
+ * only once and keeping track of how many times that string is referenced.
+ * It does so by creating a map of strings to their no of references.
+ * A new map is created for a string on its first use, and for further usages
+ * the reference count is incremented.
+ */
+static const char * make_unique_str(st_table *tbl, const char *str, long len) {
+  if (!str) {
+    return NULL;
+  }
+  else {
+    st_data_t n;
+    char *result;
+
+    if (st_lookup(tbl, (st_data_t)str, &n)) {
+      st_insert(tbl, (st_data_t)str, n+1);
+      st_get_key(tbl, (st_data_t)str, (st_data_t *)&result);
+    }
+    else {
+      result = (char *)ruby_xmalloc(len+1);
+      strncpy(result, str, len);
+      result[len] = 0;
+      st_add_direct(tbl, (st_data_t)result, 1);
+    }
+    return result;
+  }
+}
+
+/*
+ * Used to free allocation of string when it's not referenced anymore.
+ * Decrements the reference count of a string if it's still used, else
+ * the map is removed completely.
+ */
+static void delete_unique_str(st_table *tbl, const char *str) {
+  if (str) {
+    st_data_t n;
+
+    st_lookup(tbl, (st_data_t)str, &n);
+    if (n == 1) {
+      st_delete(tbl, (st_data_t *)&str, 0);
+      ruby_xfree((char *)str);
+    }
+    else {
+      st_insert(tbl, (st_data_t)str, n-1);
+    }
+  }
+}
+
+rbkit_allocation_info * new_rbkit_allocation_info(rb_trace_arg_t *tparg, st_table *str_table, st_table *object_table) {
+  VALUE obj = rb_tracearg_object(tparg);
+  VALUE klass = RBASIC_CLASS(obj);
+  VALUE path = rb_tracearg_path(tparg);
+  VALUE line = rb_tracearg_lineno(tparg);
+  VALUE method_id = rb_tracearg_method_id(tparg);
+  VALUE defined_klass = rb_tracearg_defined_class(tparg);
+
+  rbkit_allocation_info *info;
+  const char *path_cstr = RTEST(path) ? make_unique_str(str_table, RSTRING_PTR(path), RSTRING_LEN(path)) : 0;
+  VALUE class_path = (RTEST(defined_klass) && !OBJ_FROZEN(defined_klass)) ? rb_class_path_cached(defined_klass) : Qnil;
+  const char *class_path_cstr = RTEST(class_path) ? make_unique_str(str_table, RSTRING_PTR(class_path), RSTRING_LEN(class_path)) : 0;
+
+  if (st_lookup(object_table, (st_data_t)obj, (st_data_t *)&info)) {
+    /* reuse info */
+    delete_unique_str(str_table, info->path);
+    delete_unique_str(str_table, info->class_path);
+  }
+  else {
+    info = (rbkit_allocation_info *)ruby_xmalloc(sizeof(rbkit_allocation_info));
+  }
+
+  info->path = path_cstr;
+  info->line = NUM2INT(line);
+  info->method_id = method_id;
+  info->class_path = class_path_cstr;
+  info->generation = rb_gc_count();
+  st_insert(object_table, (st_data_t)obj, (st_data_t)info);
+  return info;
+}
+
+void delete_rbkit_allocation_info(rb_trace_arg_t *tparg, VALUE obj, st_table *str_table, st_table *object_table) {
+  rbkit_allocation_info *info;
+  if (st_lookup(object_table, (st_data_t)obj, (st_data_t *)&info)) {
+    st_delete(object_table, (st_data_t *)&obj, (st_data_t *)&info);
+    delete_unique_str(str_table, info->path);
+    delete_unique_str(str_table, info->class_path);
+    ruby_xfree(info);
+  }
+}

data/ext/rbkit_allocation_info.h

@@ -0,0 +1,17 @@
+#ifndef RBKIT_ALLOCATION_INFO
+#define RBKIT_ALLOCATION_INFO
+#include <ruby.h>
+#include "ruby/debug.h"
+
+typedef struct _rbkit_allocation_info {
+  const char *path;
+  unsigned long line;
+  const char *class_path;
+  VALUE method_id;
+  size_t generation;
+} rbkit_allocation_info;
+
+rbkit_allocation_info * new_rbkit_allocation_info(rb_trace_arg_t *tparg, st_table *str_table, st_table *object_table);
+void delete_rbkit_allocation_info(rb_trace_arg_t *tparg, VALUE obj, st_table *str_table, st_table *object_table);
+
+#endif

data/ext/rbkit_event.c

@@ -0,0 +1,71 @@
+#include "rbkit_event.h"
+
+VALUE rbkit_event_types_as_hash() {
+  VALUE events = rb_hash_new();
+  rb_hash_aset(events, ID2SYM(rb_intern("obj_created")), INT2FIX(obj_created));
+  rb_hash_aset(events, ID2SYM(rb_intern("obj_destroyed")), INT2FIX(obj_destroyed));
+  rb_hash_aset(events, ID2SYM(rb_intern("gc_start")), INT2FIX(gc_start));
+  rb_hash_aset(events, ID2SYM(rb_intern("gc_end_m")), INT2FIX(gc_end_m));
+  rb_hash_aset(events, ID2SYM(rb_intern("gc_end_s")), INT2FIX(gc_end_s));
+  rb_hash_aset(events, ID2SYM(rb_intern("object_space_dump")), INT2FIX(object_space_dump));
+  rb_hash_aset(events, ID2SYM(rb_intern("gc_stats")), INT2FIX(gc_stats));
+  rb_hash_aset(events, ID2SYM(rb_intern("event_collection")), INT2FIX(event_collection));
+  rb_hash_aset(events, ID2SYM(rb_intern("handshake")), INT2FIX(handshake));
+  OBJ_FREEZE(events);
+  return events;
+}
+
+rbkit_obj_created_event *new_rbkit_obj_created_event(unsigned long long object_id,
+    const char *klass, rbkit_allocation_info *info) {
+  rbkit_obj_created_event *event = malloc(sizeof(rbkit_obj_created_event));
+
+  rbkit_event_header *header = (rbkit_event_header *)event;
+  header->event_type = obj_created;
+
+  event->object_id = object_id;
+  event->klass = klass;
+  event->allocation_info = info;
+  return event;
+}
+
+rbkit_obj_destroyed_event *new_rbkit_obj_destroyed_event(unsigned long long object_id) {
+  rbkit_obj_destroyed_event *event = malloc(sizeof(rbkit_obj_destroyed_event));
+
+  rbkit_event_header *header = (rbkit_event_header *)event;
+  header->event_type = obj_destroyed;
+
+  event->object_id = object_id;
+  return event;
+}
+
+rbkit_hash_event *new_rbkit_hash_event(rbkit_event_type event_type, VALUE hash) {
+  rbkit_hash_event *event = malloc(sizeof(rbkit_hash_event));
+
+  rbkit_event_header *header = (rbkit_event_header *)event;
+  header->event_type = event_type;
+
+  event->hash = hash;
+  return event;
+}
+
+rbkit_object_space_dump_event *new_rbkit_object_space_dump_event(rbkit_object_dump *dump) {
+  rbkit_object_space_dump_event *event = malloc(sizeof(rbkit_object_space_dump_event));
+
+  rbkit_event_header *header = (rbkit_event_header *)event;
+  header->event_type = object_space_dump;
+
+  event->dump = dump;
+  return event;
+}
+
+rbkit_event_collection_event *new_rbkit_event_collection_event(void *buffer, size_t buffer_size, size_t message_count) {
+  rbkit_event_collection_event *event = malloc(sizeof(rbkit_event_collection_event));
+
+  rbkit_event_header *header = (rbkit_event_header *)event;
+  header->event_type = event_collection;
+
+  event->buffer = buffer;
+  event->buffer_size = buffer_size;
+  event->message_count = message_count;
+  return event;
+}

data/ext/rbkit_event.h

@@ -0,0 +1,63 @@
+#ifndef RBKIT_EVENT
+#define RBKIT_EVENT
+#include "rbkit_allocation_info.h"
+#include "rbkit_object_graph.h"
+
+typedef enum _event_type {
+  obj_created,
+  obj_destroyed,
+  gc_start,
+  gc_end_m,
+  gc_end_s,
+  object_space_dump,
+  gc_stats,
+  event_collection,
+  handshake
+} rbkit_event_type;
+
+VALUE rbkit_event_types_as_hash();
+
+typedef struct _rbkit_event_header {
+  rbkit_event_type event_type;
+} rbkit_event_header;
+
+typedef struct _rbkit_obj_created_event {
+  rbkit_event_header event_header;
+  unsigned long long object_id;
+  const char *klass;
+  rbkit_allocation_info *allocation_info;
+} rbkit_obj_created_event;
+
+rbkit_obj_created_event *new_rbkit_obj_created_event(unsigned long long object_id, const char *klass, rbkit_allocation_info *info);
+
+typedef struct _rbkit_obj_destroyed_event {
+  rbkit_event_header event_header;
+  unsigned long long object_id;
+} rbkit_obj_destroyed_event;
+
+rbkit_obj_destroyed_event *new_rbkit_obj_destroyed_event(unsigned long long object_id);
+
+typedef struct _rbkit_hash_event {
+  rbkit_event_header event_header;
+  VALUE hash;
+} rbkit_hash_event;
+
+rbkit_hash_event *new_rbkit_hash_event(rbkit_event_type event_type, VALUE hash);
+
+typedef struct _rbkit_object_space_dump_event {
+  rbkit_event_header event_header;
+  rbkit_object_dump *dump;
+} rbkit_object_space_dump_event;
+
+rbkit_object_space_dump_event *new_rbkit_object_space_dump_event(rbkit_object_dump *dump);
+
+typedef struct _rbkit_event_collection_event {
+  rbkit_event_header event_header;
+  void *buffer;
+  size_t buffer_size;
+  size_t message_count;
+} rbkit_event_collection_event;
+
+rbkit_event_collection_event *new_rbkit_event_collection_event(void * buffer, size_t buffer_size, size_t message_count);
+
+#endif

data/ext/rbkit_event_packer.c

@@ -0,0 +1,251 @@
+#include "rbkit_event_packer.h"
+#include "rbkit_object_graph.h"
+#include <sys/time.h>
+
+static void pack_string(msgpack_packer *packer, const char *string) {
+  if(string == NULL) {
+    msgpack_pack_nil(packer);
+  } else {
+    int length = strlen(string);
+    msgpack_pack_raw(packer, length);
+    msgpack_pack_raw_body(packer, string, length);
+  }
+}
+
+static void pack_timestamp(msgpack_packer *packer) {
+    struct timeval tv;
+    gettimeofday(&tv, NULL);
+
+    double time_in_milliseconds = (tv.tv_sec)*1000 + (tv.tv_usec)/1000;
+    msgpack_pack_double(packer, time_in_milliseconds);
+}
+
+static void pack_event_header(msgpack_packer* packer, rbkit_event_type event_type)
+{
+  msgpack_pack_int(packer, rbkit_message_field_event_type);
+  msgpack_pack_int(packer, event_type);
+
+  msgpack_pack_int(packer, rbkit_message_field_timestamp);
+  pack_timestamp(packer);
+}
+
+static unsigned long message_counter = 0;
+
+static unsigned long get_message_counter() {
+  return message_counter++;
+}
+
+static void pack_obj_created_event(rbkit_obj_created_event *event, msgpack_packer *packer) {
+  msgpack_pack_map(packer, 3);
+  pack_event_header(packer, event->event_header.event_type);
+
+  msgpack_pack_int(packer, rbkit_message_field_payload);
+  msgpack_pack_map(packer, 2);
+  msgpack_pack_int(packer, rbkit_message_field_object_id);
+  msgpack_pack_unsigned_long_long(packer, event->object_id);
+  msgpack_pack_int(packer, rbkit_message_field_class_name);
+  pack_string(packer, event->klass);
+  //TODO: pack allocation info as well
+}
+
+static void pack_obj_destroyed_event(rbkit_obj_destroyed_event *event, msgpack_packer *packer) {
+  msgpack_pack_map(packer, 3);
+  pack_event_header(packer, event->event_header.event_type);
+
+  msgpack_pack_int(packer, rbkit_message_field_payload);
+  msgpack_pack_map(packer, 1);
+  msgpack_pack_int(packer, rbkit_message_field_object_id);
+  msgpack_pack_unsigned_long_long(packer, event->object_id);
+}
+
+static void pack_event_header_only(rbkit_event_header *event_header, msgpack_packer *packer) {
+  msgpack_pack_map(packer, 2);
+  pack_event_header(packer, event_header->event_type);
+}
+
+static void pack_value_object(msgpack_packer *packer, VALUE value) {
+  switch (TYPE(value)) {
+    case T_FIXNUM:
+      msgpack_pack_long(packer, FIX2LONG(value));
+      break;
+    case T_FLOAT:
+      msgpack_pack_double(packer, rb_num2dbl(value));
+      break;
+    default:
+      ;
+      VALUE rubyString = rb_funcall(value, rb_intern("to_s"), 0, 0);
+      char *keyString = StringValueCStr(rubyString);
+      pack_string(packer, keyString);
+      break;
+  }
+}
+
+static int hash_pack_iterator(VALUE key, VALUE value, VALUE hash_arg) {
+  msgpack_packer *packer = (msgpack_packer *)hash_arg;
+
+  // pack the key
+  pack_value_object(packer,key);
+  // pack the value
+  pack_value_object(packer, value);
+  return ST_CONTINUE;
+}
+
+static void pack_hash_event(rbkit_hash_event *event, msgpack_packer *packer) {
+  msgpack_pack_map(packer, 3);
+  pack_event_header(packer, event->event_header.event_type);
+  VALUE hash = event->hash;
+  int size = RHASH_SIZE(hash);
+  msgpack_pack_int(packer, rbkit_message_field_payload);
+  msgpack_pack_map(packer, size);
+  rb_hash_foreach(hash, hash_pack_iterator, (VALUE)packer);
+}
+
+static void pack_object_space_dump_event(rbkit_object_space_dump_event *event, msgpack_packer *packer) {
+  rbkit_object_dump *dump = event->dump;
+  msgpack_pack_map(packer, 3);
+  pack_event_header(packer, event->event_header.event_type);
+  msgpack_pack_int(packer, rbkit_message_field_payload);
+  // Set size of array to hold all objects
+  msgpack_pack_array(packer, dump->object_count);
+
+  // Iterate through all object data
+  rbkit_object_dump_page * page = dump->first ;
+  while(page != NULL) {
+    rbkit_object_data *data;
+    size_t i = 0;
+    for(;i < page->count; i++) {
+      data = &(page->data[i]);
+      /* Object dump is a map that looks like this :
+       * {
+       *   object_id: <OBJECT_ID_IN_HEX>,
+       *   class: <CLASS_NAME>,
+       *   references: [<OBJECT_ID_IN_HEX>, <OBJECT_ID_IN_HEX>, ...],
+       *   file: <FILE_PATH>,
+       *   line: <LINE_NO>,
+       *   size: <SIZE>
+       * }
+       */
+
+      msgpack_pack_map(packer, 6);
+
+      // Key1 : rbkit_message_field_object_id
+      msgpack_pack_int(packer, rbkit_message_field_object_id);
+
+      // Value1 : pointer address of object
+      msgpack_pack_unsigned_long_long(packer, data->object_id);
+
+      // Key2 : rbkit_message_field_class_name
+      msgpack_pack_int(packer, rbkit_message_field_class_name);
+
+      // Value2 : Class name of object
+      pack_string(packer, data->class_name);
+
+      // Key3 : rbkit_message_field_references
+      msgpack_pack_int(packer, rbkit_message_field_references);
+
+      // Value3 : References held by the object
+      msgpack_pack_array(packer, data->reference_count);
+      if(data->reference_count != 0) {
+        size_t count = 0;
+        for(; count < data->reference_count; count++ )
+          msgpack_pack_unsigned_long_long(packer, data->references[count]);
+        free(data->references);
+      }
+
+      // Key4 : rbkit_message_field_file
+      msgpack_pack_int(packer, rbkit_message_field_file);
+
+      // Value4 : File path where object is defined
+      pack_string(packer, data->file);
+
+      // Key5 : rbkit_message_field_line
+      msgpack_pack_int(packer, rbkit_message_field_line);
+
+      // Value5 : Line no where object is defined
+      if(data->line == 0)
+        msgpack_pack_nil(packer);
+      else
+        msgpack_pack_unsigned_long(packer, data->line);
+
+      // Key6 : rbkit_message_field_size
+      msgpack_pack_int(packer, rbkit_message_field_size);
+
+      // Value6 : Size of the object in memory
+      if(data->size == 0)
+        msgpack_pack_nil(packer);
+      else
+        msgpack_pack_uint32(packer, data->size);
+    }
+    rbkit_object_dump_page * prev = page;
+    page = page->next;
+    free(prev);
+  }
+}
+
+static void pack_event_collection_event(rbkit_event_collection_event *event, msgpack_packer *packer) {
+  msgpack_sbuffer *sbuf = packer->data;
+  msgpack_pack_map(packer, 4);
+  pack_event_header(packer, event->event_header.event_type);
+  msgpack_pack_int(packer, rbkit_message_field_message_counter);
+  msgpack_pack_unsigned_long(packer, get_message_counter());
+  msgpack_pack_int(packer, rbkit_message_field_payload);
+  msgpack_pack_array(packer, event->message_count);
+  sbuf->data = realloc(sbuf->data, event->buffer_size + sbuf->size);
+  memcpy(sbuf->data + sbuf->size, event->buffer, event->buffer_size);
+  sbuf->size += event->buffer_size;
+}
+
+void pack_event(rbkit_event_header *event_header, msgpack_packer *packer) {
+  msgpack_sbuffer *sbuf = packer->data;
+  msgpack_sbuffer_clear(sbuf);
+
+  switch (event_header->event_type) {
+    case obj_created:
+      pack_obj_created_event((rbkit_obj_created_event *)event_header, packer);
+      break;
+    case obj_destroyed:
+      pack_obj_destroyed_event((rbkit_obj_destroyed_event *)event_header, packer);
+      break;
+    case gc_start:
+      pack_event_header_only(event_header, packer);
+      break;
+    case gc_end_m:
+      pack_event_header_only(event_header, packer);
+      break;
+    case gc_end_s:
+      pack_event_header_only(event_header, packer);
+      break;
+    case object_space_dump:
+      pack_object_space_dump_event((rbkit_object_space_dump_event *)event_header, packer);
+      break;
+    case gc_stats:
+      pack_hash_event((rbkit_hash_event *)event_header, packer);
+      break;
+    case handshake:
+      pack_hash_event((rbkit_hash_event *)event_header, packer);
+      break;
+    case event_collection:
+      pack_event_collection_event((rbkit_event_collection_event *)event_header, packer);
+      break;
+    default:
+      rb_raise(rb_eNotImpError,
+          "Rbkit : Unpacking of event type '%u' not implemented",
+          event_header->event_type);
+  }
+}
+
+VALUE rbkit_message_fields_as_hash() {
+  VALUE events = rb_hash_new();
+  rb_hash_aset(events, ID2SYM(rb_intern("event_type")), INT2FIX(rbkit_message_field_event_type));
+  rb_hash_aset(events, ID2SYM(rb_intern("timestamp")), INT2FIX(rbkit_message_field_timestamp));
+  rb_hash_aset(events, ID2SYM(rb_intern("payload")), INT2FIX(rbkit_message_field_payload));
+  rb_hash_aset(events, ID2SYM(rb_intern("object_id")), INT2FIX(rbkit_message_field_object_id));
+  rb_hash_aset(events, ID2SYM(rb_intern("class_name")), INT2FIX(rbkit_message_field_class_name));
+  rb_hash_aset(events, ID2SYM(rb_intern("references")), INT2FIX(rbkit_message_field_references));
+  rb_hash_aset(events, ID2SYM(rb_intern("file")), INT2FIX(rbkit_message_field_file));
+  rb_hash_aset(events, ID2SYM(rb_intern("line")), INT2FIX(rbkit_message_field_line));
+  rb_hash_aset(events, ID2SYM(rb_intern("size")), INT2FIX(rbkit_message_field_size));
+  rb_hash_aset(events, ID2SYM(rb_intern("message_counter")), INT2FIX(rbkit_message_field_message_counter));
+  OBJ_FREEZE(events);
+  return events;
+}