skylight 0.3.21 → 0.4.0.alpha1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1cf63055157626891e0d09101b21221a4d18406f
-  data.tar.gz: df489cf0c01303baf4ea5636c4fbcf40f30fa690
+  metadata.gz: c87ab5e9bed0411324b945f3d9b922cd432df9af
+  data.tar.gz: 3855aa5a3a8021f15f685d79926588656f1417db
 SHA512:
-  metadata.gz: 7537c8005076587637aad255183d13755ea45b746ce331635990bb18f6e12a52b73394720b62370f34eb1e8f361284ab29e6dce13ba552c820110fa2e84584e8
-  data.tar.gz: 29e0bfbd08c39ad41c426afafb717dd84483ea1beda96710ee9bcc7abc1694a4f20ab3544d3cf26dfe7f028eca174d4ad8ffa6381ffabe3343477190fa3d6e72
+  metadata.gz: 1077014bd4ef7b5f9b522a20d2a85cc7f9b7025a4537214e9b341514fd35c5a2db7eb93b1527fbefb334fe5eed1bbdaec566c7986407ef70a380cc6bab0a1d7b
+  data.tar.gz: 22addeda25ebf8ea1e250a65e68b026c93cf0ea26a4016db54cd3f1387c67c4941b71cadfb461fef4b10b6680a1e86f61ccbad65ee18747107b84e1c81fc26a1

data/CHANGELOG.md

@@ -1,7 +1,3 @@
-## 0.3.21 (October 8, 2014)
-
-* [BUGFIX] Skylight crashing on start won't crash entire app
-
 ## 0.3.20 (September 3, 2014)
 
 * [BUGFIX] Fix app name fetching on Windows for `skylight setup`

data/ext/extconf.rb

@@ -1,34 +1,27 @@
+require 'rbconfig'
 require 'mkmf'
 require 'yaml'
 require 'logger'
+require 'fileutils'
 
-# Must require 'rubygems/platform' vs. just requiring 'rubygems' to avoid a
-# stack overflow bug on ruby 1.9.2.
-require 'rubygems/platform'
+$:.unshift File.expand_path("../../lib", __FILE__)
+require 'skylight/version'
+require 'skylight/util/multi_io'
+require 'skylight/util/native_ext_fetcher'
+require 'skylight/util/platform'
 
-class MultiIO
-  def initialize(*targets)
-     @targets = targets
-  end
-
-  def write(*args)
-    @targets.each {|t| t.write(*args)}
-  end
-
-  def close
-    @targets.each(&:close)
-  end
-end
-
-log_file = File.open(File.expand_path("../install.log", __FILE__), "a")
-LOG = Logger.new(MultiIO.new(STDOUT, log_file))
+include Skylight::Util
 
-SKYLIGHT_REQUIRED = ENV.key?("SKYLIGHT_REQUIRED") && ENV['SKYLIGHT_REQUIRED'] !~ /^false$/i
+SKYLIGHT_INSTALL_LOG = File.expand_path("../install.log", __FILE__)
+SKYLIGHT_REQUIRED   = ENV.key?("SKYLIGHT_REQUIRED") && ENV['SKYLIGHT_REQUIRED'] !~ /^false$/i
+SKYLIGHT_FETCH_LIB  = !ENV.key?('SKYLIGHT_FETCH_LIB') || ENV['SKYLIGHT_FETCH_LIB'] !~ /^false$/i
 
-require_relative '../lib/skylight/version'
-require_relative '../lib/skylight/util/native_ext_fetcher'
+# Directory where skylight.h exists
+SKYLIGHT_HDR_PATH = ENV['SKYLIGHT_HDR_PATH'] || ENV['SKYLIGHT_LIB_PATH'] || '.'
+SKYLIGHT_LIB_PATH = ENV['SKYLIGHT_LIB_PATH'] || File.expand_path("../../lib/skylight/native/#{Platform.tuple}", __FILE__)
 
-include Skylight::Util
+# Setup logger
+LOG = Logger.new(MultiIO.new(STDOUT, File.open(SKYLIGHT_INSTALL_LOG, 'a')))
 
 # Handles terminating in the case of a failure. If we have a bug, we do not
 # want to break our customer's deploy, but extconf.rb requires a Makefile to be
@@ -49,10 +42,29 @@ def fail(msg, type=:error)
   end
 end
 
-libskylight_a = File.expand_path('../libskylight.a', __FILE__)
-libskylight_yml = File.expand_path('../libskylight.yml', __FILE__)
+#
+# === Setup paths
+#
+root              = File.expand_path('../', __FILE__)
+hdrpath           = File.expand_path(SKYLIGHT_HDR_PATH)
+libpath           = File.expand_path(SKYLIGHT_LIB_PATH)
+libskylight       = File.expand_path("libskylight.#{Platform.libext}", libpath)
+libskylight_yml   = File.expand_path('libskylight.yml', root)
+skylight_dlopen_h = File.expand_path("skylight_dlopen.h", hdrpath)
+skylight_dlopen_c = File.expand_path("skylight_dlopen.c", hdrpath)
+
+LOG.info "SKYLIGHT_HDR_PATH=#{hdrpath}; SKYLIGHT_LIB_PATH=#{libpath}"
+
+LOG.info "file exists; path=#{libskylight}" if File.exists?(libskylight)
+LOG.info "file exists; path=#{skylight_dlopen_c}" if File.exists?(skylight_dlopen_c)
+LOG.info "file exists; path=#{skylight_dlopen_h}" if File.exists?(skylight_dlopen_h)
+
+# If libskylight is not present, fetch it
+if !File.exist?(libskylight) && !File.exist?(skylight_dlopen_c) && !File.exist?(skylight_dlopen_h)
+  if !SKYLIGHT_FETCH_LIB
+    fail "libskylight.#{LIBEXT} not found -- remote download disabled; aborting install"
+  end
 
-unless File.exist?(libskylight_a)
   # Ensure that libskylight.yml is present and load it
   unless File.exist?(libskylight_yml)
     fail "`#{libskylight_yml}` does not exist"
@@ -70,27 +82,40 @@ unless File.exist?(libskylight_a)
     fail "libskylight checksums missing from `#{libskylight_yml}`"
   end
 
-  platform = Gem::Platform.local
-  arch = "#{platform.os}-#{platform.cpu}"
-
-  unless checksum = checksums[arch]
+  unless checksum = checksums[Platform.tuple]
     fail "no checksum entry for requested architecture -- " \
              "this probably means the requested architecture is not supported; " \
-             "arch=#{arch}; available=#{checksums.keys}", :info
+             "platform=#{Platform.tuple}; available=#{checksums.keys}", :info
   end
 
   begin
     res = NativeExtFetcher.fetch(
-      version: version,
-      target: libskylight_a,
+      version:  version,
+      target:   hdrpath,
       checksum: checksum,
-      arch: arch,
+      arch:     Platform.tuple,
       required: SKYLIGHT_REQUIRED,
-      logger: LOG)
+      platform: Platform.tuple,
+      logger:   LOG)
 
     unless res
       fail "could not fetch archive -- aborting skylight native extension build"
     end
+
+    # Move skylightd & libskylight to appropriate directory
+    if hdrpath != libpath
+      # Ensure the directory is present
+      FileUtils.mkdir_p libpath
+
+      # Move
+      FileUtils.mv "#{hdrpath}/libskylight.#{Platform.libext}",
+                   "#{libpath}/libskylight.#{Platform.libext}",
+                   :force => true
+
+      FileUtils.mv "#{hdrpath}/skylightd",
+                   "#{libpath}/skylightd",
+                   :force => true
+    end
   rescue => e
     fail "unable to fetch native extension; msg=#{e.message}\n#{e.backtrace.join("\n")}"
   end
@@ -98,23 +123,43 @@ end
 
 #
 #
-# ===== By this point, libskylight.a is present =====
+# ===== By this point, libskylight is present =====
 #
 #
 
-have_header 'dlfcn.h'
+def find_file(file, root = nil)
+  path = File.expand_path(file, root || '.')
+
+  unless File.exist?(path)
+    fail "#{file} missing; path=#{root}"
+  end
+end
+
+# Flag -std=c99 required for older build systems
+$CFLAGS << " -std=c99 -pedantic" # -Wall
+$VPATH  << libpath
 
-find_header("rust_support/ruby.h", ".") or fail "could not find rust support header"
-find_library("skylight", "factory", ".") or fail "could not find skylight library"
+# Where the ruby binding src is
+SRC_PATH = File.expand_path('..', __FILE__)
 
-$CFLAGS << " -Werror"
-if RbConfig::CONFIG["arch"] =~ /darwin(\d+)?/
-  $LDFLAGS << " -lpthread"
-else
-  $LDFLAGS << " -Wl,--version-script=skylight.map"
-  $LDFLAGS << " -lrt -ldl -lm -lpthread"
+$srcs = Dir[File.expand_path("*.c", SRC_PATH)].map { |f| File.basename(f) }
+
+# If the native agent support files were downloaded to a different directory,
+# explicitly the file to the list of sources.
+unless $srcs.include?('skylight_dlopen.c')
+  $srcs << "skylight_dlopen.c" # From libskylight dist
 end
 
-CONFIG['warnflags'].gsub!('-Wdeclaration-after-statement', '')
+# Make sure that the files are present
+find_file 'skylight_dlopen.h', hdrpath
+find_file 'skylight_dlopen.c', hdrpath
+find_header 'skylight_dlopen.h', hdrpath
+have_header 'dlfcn.h' or fail "could not create Makefile; dlfcn.h missing"
+
+# For escaping the GVL
+unless have_func('rb_thread_call_without_gvl', 'ruby/thread.h')
+  have_func('rb_thread_blocking_region') or abort "Ruby is unexpectedly missing rb_thread_blocking_region. This should not happen."
+end
 
-create_makefile 'skylight_native', '.' or fail "could not create makefile"
+# TODO: Compute the relative path to the location
+create_makefile 'skylight_native', File.expand_path('..', __FILE__) # or fail "could not create makefile"

data/ext/libskylight.yml

@@ -1,6 +1,6 @@
 ---
-version: "dfa09f3"
+version: "0.4.0-278b96b"
 checksums:
-  linux-x86_64: "be6c610564c66e2a098e7c22226ac879cc970bac252b2534a11b556197f2efca"
-  linux-x86: "2113e80b8afddf5f00c81590c8cbcfbb6ecaf9dbdec950eca06bb11ed1456351"
-
+  x86-linux:     "00845099a2e69fc67fcd6d23bcdcc55ff7c724b1a9c0ffb00dcdca9f6190eb09"
+  x86_64-linux:  "07dd625358a195ff2851c7aa58626d491809e48845792eb0811a1dc4a875b62d"
+  x86_64-darwin: "e8a3217bd4c5b6c5ad0193815e31a31d7632c59e27db4cf293ceccf8e12f39bb"

data/ext/skylight_native.c

@@ -1,415 +1,377 @@
-#include <skylight.h>
+#include <dlfcn.h>
 #include <ruby.h>
+#include <skylight_dlopen.h>
 
 #ifdef HAVE_RUBY_ENCODING_H
 #include <ruby/encoding.h>
 #endif
 
-/**
- * Ruby helpers
- */
-
-#define SERIALIZE(MSG)                                                                                                     \
-  ({                                                                                                                       \
-    VALUE ret;                                                                                                             \
-    size_t size;                                                                                                           \
-    RustSerializer serializer;                                                                                             \
-                                                                                                                           \
-    if (!MSG) {                                                                                                            \
-      rb_raise(rb_eRuntimeError, "No "#MSG" message to serialize");                                                        \
-    }                                                                                                                      \
-    else {                                                                                                                 \
-      CHECK_FFI(skylight_ ## MSG ## _get_serializer(MSG, &serializer), "could not get serializer for "#MSG);               \
-                                                                                                                           \
-      CHECK_FFI(skylight_serializer_get_serialized_size(serializer, &size), "could not get serialized size for "#MSG);     \
-      ret = rb_str_new(NULL, size);                                                                                        \
-                                                                                                                           \
-      CHECK_FFI(skylight_ ## MSG ## _serialize(MSG, serializer, STR2SLICE(ret)), "could not serialize "#MSG);              \
-      skylight_serializer_free(serializer);                                                                                \
-    }                                                                                                                      \
-                                                                                                                           \
-    skylight_ ## MSG ## _free(MSG);                                                                                        \
-    ret;                                                                                                                   \
+#define TO_S(VAL) \
+  RSTRING_PTR(rb_funcall(VAL, rb_intern("to_s"), 0))
+
+#define CHECK_TYPE(VAL, T)                        \
+  do {                                            \
+    if (TYPE(VAL) != T) {                         \
+      rb_raise(rb_eArgError, "expected " #VAL " to be " #T " but was '%s' (%s [%i])", \
+                TO_S(VAL), rb_obj_classname(VAL), TYPE(VAL)); \
+      return Qnil;                                \
+    }                                             \
+  } while(0)
+
+#define CHECK_NUMERIC(VAL)                        \
+  do {                                            \
+    if (TYPE(VAL) != T_BIGNUM &&                  \
+        TYPE(VAL) != T_FIXNUM) {                  \
+      rb_raise(rb_eArgError, "expected " #VAL " to be numeric but was '%s' (%s [%i])", \
+                TO_S(VAL), rb_obj_classname(VAL), TYPE(VAL)); \
+      return Qnil;                                \
+    }                                             \
+  } while(0)                                      \
+
+#define BUF2STR(buf)                            \
+  ({                                            \
+    sky_buf_t b = (buf);                        \
+    VALUE str = rb_str_new(b.data, b.len);      \
+    rb_enc_associate(str, rb_utf8_encoding());  \
+    str;                                        \
   })
 
-/**
- * Ruby types defined here
- */
-
-VALUE rb_mSkylight;
-VALUE rb_mUtil;
-VALUE rb_cClock;
-VALUE rb_cHello;
-VALUE rb_cError;
-VALUE rb_cTrace;
-VALUE rb_cBatch;
-
-/**
- * class Skylight::Util::Clock
- */
+#define STR2BUF(str)           \
+  ({                           \
+    sky_buf_t buf;             \
+    VALUE s = (str);           \
+    buf.data = RSTRING_PTR(s); \
+    buf.len = RSTRING_LEN(s);  \
+    buf;                       \
+  })
 
-static VALUE clock_high_res_time(VALUE self) {
-  uint64_t time;
-  CHECK_FFI(skylight_high_res_time(&time), "Could not get high-res time");
-  return ULL2NUM(time);
-}
+#define CHECK_FFI(success, message)               \
+  do {                                            \
+    if ((success) < 0 ) {                         \
+      rb_raise(rb_eRuntimeError, message);        \
+      return Qnil;                                \
+    }                                             \
+  } while(0)
+
+#define My_Struct(name, Type, msg)                \
+  Get_Struct(name, self, Type, msg);              \
+
+#define Transfer_My_Struct(name, Type, msg)       \
+  My_Struct(name, Type, msg);                     \
+  DATA_PTR(self) = NULL;                          \
+
+#define Transfer_Struct(name, obj, Type, msg)     \
+  Get_Struct(name, obj, Type, msg);               \
+  DATA_PTR(obj) = NULL;                           \
+
+#define Get_Struct(name, obj, Type, msg)          \
+  Type name;                                      \
+  Data_Get_Struct(obj, Type, name);               \
+  if (name == NULL) {                             \
+    rb_raise(rb_eRuntimeError, "%s", msg);        \
+  }
 
 /**
- * class Skylight::Hello
+ * Ruby GVL helpers
  */
 
-static VALUE hello_new(VALUE klass, VALUE version, VALUE config) {
-  RustHello hello;
-
-  CHECK_TYPE(version, T_STRING);
-  CHECK_TYPE(config, T_FIXNUM);
+#if defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL) && \
+    defined(HAVE_RUBY_THREAD_H)
 
-  CHECK_FFI(skylight_hello_new(STR2SLICE(version), FIX2INT(config), &hello), "could not create new Hello");
+// Ruby 2.0+
+#include <ruby/thread.h>
+typedef void* (*blocking_fn_t)(void*);
+#define WITHOUT_GVL(fn, a) \
+  rb_thread_call_without_gvl((blocking_fn_t)(fn), (a), 0, 0)
 
-  return Data_Wrap_Struct(rb_cHello, NULL, skylight_hello_free, hello);
-}
+// Ruby 1.9
+#elif defined(HAVE_RB_THREAD_BLOCKING_REGION)
 
-static VALUE hello_load(VALUE self, VALUE protobuf) {
-  CHECK_TYPE(protobuf, T_STRING);
+typedef VALUE (*blocking_fn_t)(void*);
+#define WITHOUT_GVL(fn, a) \
+  rb_thread_blocking_region((blocking_fn_t)(fn), (a), 0, 0)
 
-  RustHello hello;
 
-  CHECK_FFI(skylight_hello_load(STR2SLICE(protobuf), &hello), "Could not load Hello");
-
-  return Data_Wrap_Struct(rb_cHello, NULL, skylight_hello_free, hello);
-}
-
-static const char* freedHello = "You can't do anything with a Hello once it's been serialized";
-
-static VALUE hello_get_version(VALUE self) {
-  RustSlice slice;
+#endif
 
-  My_Struct(hello, RustHello, freedHello);
 
-  CHECK_FFI(skylight_hello_get_version(hello, &slice), "could not get version from Hello");
+/**
+ * Ruby types defined here
+ */
 
-  return SLICE2STR(slice);
-}
+VALUE rb_mSkylight;
+VALUE rb_mUtil;
+VALUE rb_cClock;
+VALUE rb_cTrace;
+VALUE rb_cInstrumenter;
 
-static VALUE hello_cmd_length(VALUE self) {
-  My_Struct(hello, RustHello, freedHello);
+static const char* no_instrumenter_msg =
+  "Instrumenter not currently running";
 
-  uint32_t length;
+static const char* consumed_trace_msg =
+  "Trace objects cannot be used once it has been submitted to the instrumenter";
 
-  CHECK_FFI(skylight_hello_cmd_length(hello, &length), "Could not get length of Hello commands");
+static VALUE
+load_libskylight(VALUE klass, VALUE path) {
+  int res;
 
-  return UINT2NUM(length);
-}
+  CHECK_TYPE(path, T_STRING);
 
-static VALUE hello_add_cmd_part(VALUE self, VALUE rb_string) {
-  My_Struct(hello, RustHello, freedHello);
+  // Already loaded
+  if (sky_hrtime != 0) {
+    return Qnil;
+  }
 
-  CHECK_TYPE(rb_string, T_STRING);
+  res = sky_load_libskylight(StringValueCStr(path));
 
-  CHECK_FFI(skylight_hello_cmd_add(hello, STR2SLICE(rb_string)), "Could not add command part to Hello");
+  if (res < 0) {
+    rb_raise(rb_eRuntimeError, "[SKYLIGHT] dlerror; msg=%s", dlerror());
+    return Qnil;
+  }
 
   return Qnil;
 }
 
-static VALUE hello_cmd_get(VALUE self, VALUE rb_off) {
-  uint32_t off;
-  RustSlice slice;
-  My_Struct(hello, RustHello, freedHello);
-
-  CHECK_TYPE(rb_off, T_FIXNUM);
-  off = FIX2INT(rb_off);
-
-  CHECK_FFI(skylight_hello_get_cmd(hello, off, &slice), "Could not get command part from Hello");
-
-  return SLICE2STR(slice);
-}
+/*
+ *
+ * class Skylight::Util::Clock
+ *
+ */
 
-static VALUE hello_serialize(VALUE self) {
-  Transfer_My_Struct(hello, RustHello, freedHello);
-  return SERIALIZE(hello);
+static VALUE
+clock_high_res_time(VALUE self) {
+  return ULL2NUM(sky_hrtime());
 }
 
-/**
- * class Skylight::Error
+/*
+ *
+ * class Skylight::Instrumenter
+ *
  */
 
-static VALUE error_new(VALUE klass, VALUE group, VALUE description) {
-  RustError error;
-
-  CHECK_TYPE(group, T_STRING);
-  CHECK_TYPE(description, T_STRING);
+static VALUE
+instrumenter_new(VALUE klass, VALUE rb_env) {
+  sky_instrumenter_t* instrumenter;
+  sky_buf_t env[256];
 
-  CHECK_FFI(skylight_error_new(STR2SLICE(group), STR2SLICE(description), &error), "could not create new Error");
+  CHECK_TYPE(rb_env, T_ARRAY);
 
-  return Data_Wrap_Struct(rb_cError, NULL, skylight_error_free, error);
-}
-
-static VALUE error_load(VALUE self, VALUE protobuf) {
-  CHECK_TYPE(protobuf, T_STRING);
-
-  RustError error;
-
-  CHECK_FFI(skylight_error_load(STR2SLICE(protobuf), &error), "Could not load Error");
+  if (RARRAY_LEN(rb_env) >= 256) {
+    rb_raise(rb_eArgError, "environment array too long");
+    return Qnil;
+  }
 
-  return Data_Wrap_Struct(rb_cError, NULL, skylight_error_free, error);
-}
+  int i;
+  int envc = (int) RARRAY_LEN(rb_env);
 
-static const char* freedError = "You can't do anything with a Error once it's been serialized";
+  for (i = 0; i < envc; ++i) {
+    VALUE val = rb_ary_entry(rb_env, i);
 
-static VALUE error_get_group(VALUE self) {
-  RustSlice slice;
+    // Make sure it is a string
+    CHECK_TYPE(val, T_STRING);
 
-  My_Struct(error, RustError, freedError);
+    env[i] = STR2BUF(val);
+  }
 
-  CHECK_FFI(skylight_error_get_group(error, &slice), "could not get group from Error");
+  CHECK_FFI(
+      sky_instrumenter_new(env, envc, &instrumenter),
+      "failed to initialize instrumenter");
 
-  return SLICE2STR(slice);
+  return Data_Wrap_Struct(rb_cInstrumenter, NULL, sky_instrumenter_free, instrumenter);
 }
 
-static VALUE error_get_description(VALUE self) {
-  RustSlice slice;
+static void*
+instrumenter_start_nogvl(sky_instrumenter_t* instrumenter) {
+  /*
+   * Cannot use CHECK_FFI in here
+   */
 
-  My_Struct(error, RustError, freedError);
+  if (sky_instrumenter_start(instrumenter) == 0) {
+    return (void*) Qtrue;
+  }
+  else {
+    return (void*) Qfalse;
+  }
+}
 
-  CHECK_FFI(skylight_error_get_description(error, &slice), "could not get description from Error");
+static VALUE
+instrumenter_start(VALUE self) {
+  My_Struct(instrumenter, sky_instrumenter_t*, no_instrumenter_msg);
 
-  return SLICE2STR(slice);
+  return (VALUE) WITHOUT_GVL(instrumenter_start_nogvl, instrumenter);
 }
 
-static VALUE error_get_details(VALUE self) {
-  RustSlice slice;
-
-  My_Struct(error, RustError, freedError);
+static VALUE
+instrumenter_stop(VALUE self) {
+  My_Struct(instrumenter, sky_instrumenter_t*, no_instrumenter_msg);
 
-  CHECK_FFI(skylight_error_get_details(error, &slice), "could not get details from Error");
+  CHECK_FFI(
+      sky_instrumenter_stop(instrumenter),
+      "native Instrumenter#stop failed");
 
-  return SLICE2STR(slice);
+  return Qnil;
 }
 
-static VALUE error_set_details(VALUE self, VALUE details) {
-  CHECK_TYPE(details, T_STRING);
+static VALUE
+instrumenter_submit_trace(VALUE self, VALUE rb_trace) {
+  My_Struct(instrumenter, sky_instrumenter_t*, no_instrumenter_msg);
+  Transfer_Struct(trace, rb_trace, sky_trace_t*, consumed_trace_msg);
 
-  My_Struct(error, RustError, freedError);
-
-  CHECK_FFI(skylight_error_set_details(error, STR2SLICE(details)), "could not set Error details");
+  CHECK_FFI(
+      sky_instrumenter_submit_trace(instrumenter, trace),
+      "native Instrumenter#submit_trace failed");
 
   return Qnil;
 }
 
-static VALUE error_serialize(VALUE self) {
-  Transfer_My_Struct(error, RustError, freedError);
-  return SERIALIZE(error);
-}
-
-/**
- * Skylight::Trace
+/*
+ *
+ * class Skylight::Trace
+ *
  */
 
-static const char* freedTrace = "You can't do anything with a Trace once it's been serialized or moved into a Batch";
-
-static VALUE trace_new(VALUE self, VALUE started_at, VALUE uuid) {
-  CHECK_NUMERIC(started_at);
+static VALUE
+trace_new(VALUE klass, VALUE start, VALUE uuid, VALUE endpoint) {
+  CHECK_NUMERIC(start);
   CHECK_TYPE(uuid, T_STRING);
+  CHECK_TYPE(endpoint, T_STRING);
 
-  RustTrace trace;
+  sky_trace_t* trace;
 
-  CHECK_FFI(skylight_trace_new(NUM2ULL(started_at), STR2SLICE(uuid), &trace), "Could not created Trace");
+  CHECK_FFI(
+      sky_trace_new(NUM2ULL(start), STR2BUF(uuid), STR2BUF(endpoint), &trace),
+      "native Trace#new failed");
 
-  return Data_Wrap_Struct(rb_cTrace, NULL, skylight_trace_free, trace);
+  return Data_Wrap_Struct(rb_cTrace, NULL, sky_trace_free, trace);
 }
 
-static VALUE trace_name_from_serialized(VALUE self, VALUE protobuf) {
-  CHECK_TYPE(protobuf, T_STRING);
-
-  RustString trace_name;
+static VALUE
+trace_get_started_at(VALUE self) {
+  uint64_t start;
+  My_Struct(trace, sky_trace_t*, consumed_trace_msg);
 
-  CHECK_FFI(skylight_trace_name_from_serialized_into_new_buffer(STR2SLICE(protobuf), &trace_name), "Could not read name from serialized Trace");
+  CHECK_FFI(
+      sky_trace_start(trace, &start),
+      "native Trace#started_at failed");
 
-  return SKYLIGHT_RUSTSTR2STR(trace_name);
+  return ULL2NUM(start);
 }
 
-static VALUE trace_get_started_at(VALUE self) {
-  My_Struct(trace, RustTrace, freedTrace);
+static VALUE
+trace_get_endpoint(VALUE self) {
+  sky_buf_t endpoint;
+  My_Struct(trace, sky_trace_t*, consumed_trace_msg);
 
-  uint64_t started_at;
+  CHECK_FFI(
+      sky_trace_endpoint(trace, &endpoint),
+      "native Trace#endpoint failed");
 
-  CHECK_FFI(skylight_trace_get_started_at(trace, &started_at), "Could not get Trace started_at");
-
-  return ULL2NUM(started_at);
+  return BUF2STR(endpoint);
 }
 
-static VALUE trace_set_name(VALUE self, VALUE name) {
-  CHECK_TYPE(name, T_STRING);
-
-  My_Struct(trace, RustTrace, freedTrace);
-  CHECK_FFI(skylight_trace_set_name(trace, STR2SLICE(name)), "Could not set Trace name");
-  return Qnil;
-}
+static VALUE
+trace_set_endpoint(VALUE self, VALUE endpoint) {
+  CHECK_TYPE(endpoint, T_STRING);
+  My_Struct(trace, sky_trace_t*, consumed_trace_msg);
 
-static VALUE trace_get_name(VALUE self) {
-  My_Struct(trace, RustTrace, freedTrace);
+  CHECK_FFI(
+      sky_trace_set_endpoint(trace, STR2BUF(endpoint)),
+      "native Trace#set_endpoint failed");
 
-  RustSlice string;
-  if (skylight_trace_get_name(trace, &string)) {
-    return SLICE2STR(string);
-  } else {
-    return Qnil;
-  }
+  return Qnil;
 }
 
-static VALUE trace_get_uuid(VALUE self) {
-  My_Struct(trace, RustTrace, freedTrace);
+static VALUE
+trace_get_uuid(VALUE self) {
+  sky_buf_t uuid;
+  My_Struct(trace, sky_trace_t*, consumed_trace_msg);
 
-  RustSlice slice;
+  CHECK_FFI(
+      sky_trace_uuid(trace, &uuid),
+      "native Trace#uuid failed");
 
-  CHECK_FFI(skylight_trace_get_uuid(trace, &slice), "Could not get uuid from Trace");
-
-  return SLICE2STR(slice);
+  return BUF2STR(uuid);
 }
 
-static VALUE trace_start_span(VALUE self, VALUE time, VALUE category) {
+static VALUE
+trace_start_span(VALUE self, VALUE time, VALUE category) {
   uint32_t span;
-  My_Struct(trace, RustTrace, freedTrace);
+  My_Struct(trace, sky_trace_t*, consumed_trace_msg);
 
   CHECK_NUMERIC(time);
   CHECK_TYPE(category, T_STRING);
 
-  CHECK_FFI(skylight_trace_start_span(trace, NUM2ULL(time), STR2SLICE(category), &span), "Could not start Span");
+  CHECK_FFI(
+      sky_trace_instrument(trace, NUM2ULL(time), STR2BUF(category), &span),
+      "native Trace#start_span failed");
 
   return UINT2NUM(span);
 }
 
-static VALUE trace_stop_span(VALUE self, VALUE span_index, VALUE time) {
-  My_Struct(trace, RustTrace, freedTrace);
+static VALUE
+trace_stop_span(VALUE self, VALUE span, VALUE time) {
+  My_Struct(trace, sky_trace_t*, consumed_trace_msg);
 
   CHECK_NUMERIC(time);
-  CHECK_TYPE(span_index, T_FIXNUM);
+  CHECK_TYPE(span, T_FIXNUM);
 
-  CHECK_FFI(skylight_trace_stop_span(trace, FIX2UINT(span_index), NUM2ULL(time)), "Could not stop Span");
+  CHECK_FFI(
+      sky_trace_span_done(trace, FIX2UINT(span), NUM2ULL(time)),
+      "native Trace#stop_span failed");
 
   return Qnil;
 }
 
-static VALUE trace_span_set_title(VALUE self, VALUE index, VALUE title) {
-  My_Struct(trace, RustTrace, freedTrace);
+static VALUE
+trace_span_set_title(VALUE self, VALUE span, VALUE title) {
+  My_Struct(trace, sky_trace_t*, consumed_trace_msg);
 
-  CHECK_TYPE(index, T_FIXNUM);
+  CHECK_TYPE(span, T_FIXNUM);
   CHECK_TYPE(title, T_STRING);
 
-  CHECK_FFI(skylight_trace_span_set_title(trace, NUM2LL(index), STR2SLICE(title)), "Could not set Span title");
-
-  return Qnil;
-}
-
-static VALUE trace_span_set_description(VALUE self, VALUE index, VALUE description) {
-  My_Struct(trace, RustTrace, freedTrace);
-
-  CHECK_TYPE(index, T_FIXNUM);
-  CHECK_TYPE(description, T_STRING);
+  CHECK_FFI(
+      sky_trace_span_set_title(trace, FIX2UINT(span), STR2BUF(title)),
+      "native Trace#span_set_title failed");
 
-  CHECK_FFI(skylight_trace_span_set_description(trace, NUM2LL(index), STR2SLICE(description)), "Could not set Span description");
   return Qnil;
 }
 
-static VALUE trace_serialize(VALUE self) {
-  Transfer_My_Struct(trace, RustTrace, freedTrace);
-  return SERIALIZE(trace);
-}
-
-/**
- * class Skylight::Batch
- */
-
-static const char* freedBatch = "You can't do anything with a Batch once it's been serialized";
-
-VALUE batch_new(VALUE klass, VALUE rb_timestamp, VALUE rb_hostname) {
-  CHECK_NUMERIC(rb_timestamp);
-
-  RustSlice* hostname = NULL;
-  RustSlice tmp;
-
-  uint32_t timestamp = (uint32_t) NUM2ULONG(rb_timestamp);
-
-  if (rb_hostname != Qnil) {
-    CHECK_TYPE(rb_hostname, T_STRING);
-    tmp = STR2SLICE(rb_hostname);
-    hostname = &tmp;
-  }
-
-  RustBatch batch;
-
-  CHECK_FFI(skylight_batch_new(timestamp, hostname, &batch), "Could not create Batch");
-
-  return Data_Wrap_Struct(rb_cBatch, NULL, skylight_batch_free, batch);
-}
-
-VALUE batch_set_endpoint_count(VALUE self, VALUE rb_endpoint_name, VALUE rb_count) {
-  CHECK_TYPE(rb_endpoint_name, T_STRING);
-  CHECK_NUMERIC(rb_count);
+static VALUE
+trace_span_set_description(VALUE self, VALUE span, VALUE desc) {
+  My_Struct(trace, sky_trace_t*, consumed_trace_msg);
 
-  My_Struct(batch, RustBatch, freedBatch);
+  CHECK_TYPE(span, T_FIXNUM);
+  CHECK_TYPE(desc, T_STRING);
 
-  CHECK_FFI(skylight_batch_set_endpoint_count(batch, STR2SLICE(rb_endpoint_name), NUM2ULL(rb_count)), "Could not set count for Endpoint in Batch");
+  CHECK_FFI(
+      sky_trace_span_set_desc(trace, FIX2UINT(span), STR2BUF(desc)),
+      "native Trace#span_set_description failed");
 
   return Qnil;
 }
 
-VALUE batch_move_in(VALUE self, VALUE rb_string) {
-  CHECK_TYPE(rb_string, T_STRING);
-
-  My_Struct(batch, RustBatch, freedBatch);
-
-  CHECK_FFI(skylight_batch_move_in(batch, STR2SLICE(rb_string)), "Could not add serialized Trace to Batch");
-
-  return Qnil;
-}
-
-VALUE batch_serialize(VALUE self) {
-  Transfer_My_Struct(batch, RustBatch, freedBatch);
-  return SERIALIZE(batch);
-}
-
 void Init_skylight_native() {
   rb_mSkylight = rb_define_module("Skylight");
-  rb_mUtil  = rb_define_module_under(rb_mSkylight, "Util");
+  rb_define_singleton_method(rb_mSkylight, "load_libskylight", load_libskylight, 1);
 
+  rb_mUtil  = rb_define_module_under(rb_mSkylight, "Util");
   rb_cClock = rb_define_class_under(rb_mUtil, "Clock", rb_cObject);
   rb_define_method(rb_cClock, "native_hrtime", clock_high_res_time, 0);
 
-  rb_cHello = rb_define_class_under(rb_mSkylight, "Hello", rb_cObject);
-  rb_define_singleton_method(rb_cHello, "native_new", hello_new, 2);
-  rb_define_singleton_method(rb_cHello, "native_load", hello_load, 1);
-  rb_define_method(rb_cHello, "native_get_version", hello_get_version, 0);
-  rb_define_method(rb_cHello, "native_cmd_length", hello_cmd_length, 0);
-  rb_define_method(rb_cHello, "native_add_cmd_part", hello_add_cmd_part, 1);
-  rb_define_method(rb_cHello, "native_cmd_get", hello_cmd_get, 1);
-  rb_define_method(rb_cHello, "native_serialize", hello_serialize, 0);
-
-  rb_cError = rb_define_class_under(rb_mSkylight, "Error", rb_cObject);
-  rb_define_singleton_method(rb_cError, "native_new", error_new, 2);
-  rb_define_singleton_method(rb_cError, "native_load", error_load, 1);
-  rb_define_method(rb_cError, "native_get_group", error_get_group, 0);
-  rb_define_method(rb_cError, "native_get_description", error_get_description, 0);
-  rb_define_method(rb_cError, "native_get_details", error_get_details, 0);
-  rb_define_method(rb_cError, "native_set_details", error_set_details, 1);
-  rb_define_method(rb_cError, "native_serialize", error_serialize, 0);
-
   rb_cTrace = rb_define_class_under(rb_mSkylight, "Trace", rb_cObject);
-  rb_define_singleton_method(rb_cTrace, "native_new", trace_new, 2);
-  rb_define_singleton_method(rb_cTrace, "native_name_from_serialized", trace_name_from_serialized, 1);
+  rb_define_singleton_method(rb_cTrace, "native_new", trace_new, 3);
   rb_define_method(rb_cTrace, "native_get_started_at", trace_get_started_at, 0);
-  rb_define_method(rb_cTrace, "native_get_name", trace_get_name, 0);
-  rb_define_method(rb_cTrace, "native_set_name", trace_set_name, 1);
+  rb_define_method(rb_cTrace, "native_get_endpoint", trace_get_endpoint, 0);
+  rb_define_method(rb_cTrace, "native_set_endpoint", trace_set_endpoint, 1);
   rb_define_method(rb_cTrace, "native_get_uuid", trace_get_uuid, 0);
-  rb_define_method(rb_cTrace, "native_serialize", trace_serialize, 0);
   rb_define_method(rb_cTrace, "native_start_span", trace_start_span, 2);
   rb_define_method(rb_cTrace, "native_stop_span", trace_stop_span, 2);
   rb_define_method(rb_cTrace, "native_span_set_title", trace_span_set_title, 2);
   rb_define_method(rb_cTrace, "native_span_set_description", trace_span_set_description, 2);
 
-  rb_cBatch = rb_define_class_under(rb_mSkylight, "Batch", rb_cObject);
-  rb_define_singleton_method(rb_cBatch, "native_new", batch_new, 2);
-  rb_define_method(rb_cBatch, "native_move_in", batch_move_in, 1);
-  rb_define_method(rb_cBatch, "native_set_endpoint_count", batch_set_endpoint_count, 2);
-  rb_define_method(rb_cBatch, "native_serialize", batch_serialize, 0);
+  rb_cInstrumenter = rb_define_class_under(rb_mSkylight, "Instrumenter", rb_cObject);
+  rb_define_singleton_method(rb_cInstrumenter, "native_new", instrumenter_new, 1);
+  rb_define_method(rb_cInstrumenter, "native_start", instrumenter_start, 0);
+  rb_define_method(rb_cInstrumenter, "native_stop", instrumenter_stop, 0);
+  rb_define_method(rb_cInstrumenter, "native_submit_trace", instrumenter_submit_trace, 1);
 }