skylight 0.3.6 → 0.3.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3b26b3f575af56669c5257a37d8d7ca11544aba4
-  data.tar.gz: 5fb2964195f3d146693f62b6593ff2b0bbf3944d
+  metadata.gz: 727271788a0fddacdf3b7e53451c413023d74a0d
+  data.tar.gz: 0b911dd320834be2608b7cd294e5aacf395188b7
 SHA512:
-  metadata.gz: 5e9759155ce35d86bd96b058788b153544dff9aa73d08cfb4f742ddd5dc2871b4c4c8bc4e4799eb006b59e3e8bb99b89920b98a67698fd601d612793b2f68ec3
-  data.tar.gz: 0009517b20943ce01703c10210b925f3d687b16e471f7b57af1066bbdeb28e88f3f91937b00a4c4942167f2d7983d89b1621d10891f16962c644965dbf573fb8
+  metadata.gz: 425fe8a9ece2086b79e08cadcd7687c1d808ce65e2772c6b3d457c7f5b79c57fe9284d78f9964a7a161e95f67d0e87d2cf4dc89370488d6d7ad7906abec53357
+  data.tar.gz: bbbe029afd5bfaa9c203ad7103ac818bdebbc95a78b94435ed43344b5a00feb74e7992d75bc8fdca27e1fe63dadb784fcd64ef63abbb41130092c4511988f5ea

data/ext/extconf.rb

@@ -1,91 +1,89 @@
 require 'mkmf'
-require 'rbconfig'
-require 'net/http'
-require 'zlib'
 require 'yaml'
-require 'digest/sha2'
+require 'logger'
 
-require_relative '../lib/skylight/version.rb'
+LOG = Logger.new(STDOUT)
+SKYLIGHT_REQUIRED = ENV.key?("SKYLIGHT_REQUIRED") && ENV['SKYLIGHT_REQUIRED'] !~ /^false$/i
 
-checksums = YAML.load_file("checksums.yml")
+require_relative '../lib/skylight/version'
+require_relative '../lib/skylight/util/native_ext_fetcher'
 
-rust_version = "74fb9b3"
+include Skylight::Util
 
-arch = RbConfig::CONFIG["arch"]
+# 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
+# present upon a successful exit. To satisfy this requirement, we create a
+# dummy Makefile.
+def fail(msg)
+  LOG.error msg
 
-url = "https://github.com/skylightio/skylight-rust/releases/download/#{rust_version}/libskylight.#{arch}.a.gz"
+  if SKYLIGHT_REQUIRED
+    exit 1
+  else
+    File.open("Makefile", "w") do |file|
+      file.puts "default:"
+      file.puts "install:"
+    end
 
-required = ENV.key?("SKYLIGHT_REQUIRED")
+    exit
+  end
+end
 
-unless File.exist?("libskylight.a")
-  puts "[SKYLIGHT] [#{Skylight::VERSION}] Downloading from #{url.inspect}"
-  location = nil
-  uri = URI.parse(url)
+libskylight_a = File.expand_path('../libskylight.a', __FILE__)
+libskylight_yml = File.expand_path('../libskylight.yml', __FILE__)
 
-  begin
-    Net::HTTP.start("github.com", 443, use_ssl: true) do |http|
-      response = http.get(uri.request_uri)
-      location = response["Location"]
-    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"
+  end
 
-    if location
-      archive = nil
-
-      uri = URI(location)
-      Net::HTTP.start(uri.host, uri.port, use_ssl: true) do |http|
-        response = http.get(uri.request_uri)
-        archive = response.body
-      end
-    else
-      raise "No location returned" if required
-      missing_a = true
-    end
-  rescue Timeout::Error, Errno::EINVAL, Errno::ECONNRESET, EOFError,
-       Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError, Net::ProtocolError
-    raise if required
-    missing_a = true
+  unless libskylight_info = YAML.load_file(libskylight_yml)
+    fail "`#{libskylight_yml}` does not contain data"
   end
 
-  unless missing_a
-    expected_checksum = checksums[arch]
-    actual_checksum = Digest::SHA2.hexdigest(archive)
+  unless version = libskylight_info["version"]
+    fail "libskylight version missing from `#{libskylight_yml}`"
+  end
 
-    if expected_checksum == actual_checksum
-      inflater, dest = Zlib::Inflate.new(32 + Zlib::MAX_WBITS), ""
-      dest << inflater.inflate(archive)
-      inflater.close
+  unless checksums = libskylight_info["checksums"]
+    fail "libskylight checksums missing from `#{libskylight_yml}`"
+  end
 
-      File.open("libskylight.a", "w") { |file| file.write dest }
-    else
-      raise "Checksum mismatched; expected=#{expected_checksum.inspect}; actual=#{actual_checksum.inspect}" if required
-      missing_a = true
+  begin
+    res = NativeExtFetcher.fetch(
+      version: version,
+      target: libskylight_a,
+      checksums: checksums,
+      required: SKYLIGHT_REQUIRED,
+      logger: LOG)
+
+    unless res
+      fail "could not fetch archive -- aborting skylight native extension build"
     end
+  rescue => e
+    fail "unable to fetch native extension; msg=#{e.message}\n#{e.backtrace.join("\n")}"
   end
 end
 
-if missing_a
-  puts "[SKYLIGHT] [#{Skylight::VERSION}] Could not download Skylight native code from Github; version=#{rust_version.inspect}; arch=#{arch.inspect}"
+#
+#
+# ===== By this point, libskylight.a is present =====
+#
+#
 
-  exit 1 if required
+have_header 'dlfcn.h'
 
-  File.open("Makefile", "w") do |file|
-    file.puts "default:"
-    file.puts "install:"
-  end
-else
-  have_header 'dlfcn.h'
+find_library("skylight", "factory", ".")
 
-  find_library("skylight", "factory", ".")
-
-  $CFLAGS << " -Werror"
-  if RbConfig::CONFIG["arch"] =~ /darwin(\d+)?/
-    $LDFLAGS << " -lpthread"
-  else
-    $LDFLAGS << " -Wl,--version-script=skylight.map"
-    $LDFLAGS << " -lrt -ldl -lm -lpthread"
-  end
+$CFLAGS << " -Werror"
+if RbConfig::CONFIG["arch"] =~ /darwin(\d+)?/
+  $LDFLAGS << " -lpthread"
+else
+  $LDFLAGS << " -Wl,--version-script=skylight.map"
+  $LDFLAGS << " -lrt -ldl -lm -lpthread"
+end
 
-  CONFIG['warnflags'].gsub!('-Wdeclaration-after-statement', '')
+CONFIG['warnflags'].gsub!('-Wdeclaration-after-statement', '')
 
-  create_makefile 'skylight_native', '.'
-end
+create_makefile 'skylight_native', '.'

data/ext/libskylight.yml

@@ -0,0 +1,6 @@
+---
+version: "74fb9b3"
+checksums:
+  linux-x86_64: "98b04f7d73c1894cc79621a135b4598a679c421f5ff3eecc652f84ba07258d9c"
+  linux-x86: "1d4bbd58e319237b18752607d087ce0c895fe99c58482e994abe62a9f07d41dd"
+

data/ext/skylight.h

@@ -0,0 +1,93 @@
+#ifndef __SKYLIGHT_H__
+#define __SKYLIGHT_H__
+
+#include <stddef.h>
+#include <stdint.h>
+#include <stdbool.h>
+
+/**
+ * Rust types
+ */
+
+typedef struct {
+  size_t fill;    // in bytes; if zero, heapified
+  size_t alloc;   // in bytes
+  uint8_t data[0];
+} rust_str;
+
+typedef struct {
+  char * data;
+  long len;
+} RustSlice;
+
+typedef struct {
+  uint8_t discrim;
+  RustSlice slice;
+} OptionRustSlice;
+
+typedef rust_str * RustString;
+typedef RustString RustVector;
+
+/**
+ * Externed Rust functions from libskylight
+ */
+
+typedef void * RustHello;
+typedef void * RustError;
+typedef void * RustTrace;
+typedef void * RustBatch;
+
+void factory();
+
+// Rust skylight_hello prototypes
+bool skylight_hello_new(RustSlice, uint32_t, RustHello*);
+bool skylight_hello_free(RustHello);
+bool skylight_hello_load(RustSlice, RustHello*);
+bool skylight_hello_cmd_add(RustHello, RustSlice);
+bool skylight_hello_get_version(RustHello, RustSlice*);
+bool skylight_hello_cmd_length(RustHello, uint32_t*);
+bool skylight_hello_get_cmd(RustHello, int, RustSlice*);
+bool skylight_hello_serialize_into_new_buffer(RustHello, RustString*);
+bool skylight_high_res_time(uint64_t*);
+
+// Rust skylight_trace prototypes
+bool skylight_trace_new(uint64_t, RustSlice, RustTrace*);
+bool skylight_trace_free(RustTrace);
+bool skylight_trace_load(RustSlice, RustTrace*);
+bool skylight_trace_name_from_serialized_into_new_buffer(RustSlice, RustString*);
+bool skylight_trace_get_started_at(RustTrace, uint64_t*);
+bool skylight_trace_set_name(RustTrace, RustSlice);
+bool skylight_trace_get_name(RustTrace, RustSlice*);
+bool skylight_trace_get_uuid(RustTrace, RustSlice*);
+bool skylight_trace_start_span(RustTrace, uint64_t, RustSlice, uint32_t*);
+bool skylight_trace_stop_span(RustTrace, uint32_t, uint64_t);
+bool skylight_trace_serialize_into_new_buffer(RustTrace, RustString*);
+bool skylight_trace_span_set_title(RustTrace, uint64_t, RustSlice);
+bool skylight_trace_span_set_description(RustTrace, uint64_t, RustSlice);
+
+// Trace annotation methods
+bool skylight_trace_add_annotation_int(RustTrace, uint32_t, uint32_t*, RustSlice*, int64_t);
+bool skylight_trace_add_annotation_double(RustTrace, uint32_t, uint32_t*, RustSlice*, double);
+bool skylight_trace_add_annotation_string(RustTrace, uint32_t, uint32_t*, RustSlice*, RustSlice);
+bool skylight_trace_add_annotation_nested(RustTrace, uint32_t, uint32_t*, RustSlice*, uint32_t*);
+
+// Batch methods
+bool skylight_batch_new(uint32_t, RustString, RustBatch*);
+bool skylight_batch_free(RustBatch);
+bool skylight_batch_set_endpoint_count(RustBatch, RustSlice, uint64_t);
+bool skylight_batch_move_in(RustBatch, RustString);
+bool skylight_batch_serialize_into_new_buffer(RustBatch, RustString*);
+
+// Error methods
+bool skylight_error_new(RustSlice, RustSlice, RustError*);
+bool skylight_error_free(RustError);
+bool skylight_error_load(RustSlice, RustError*);
+bool skylight_error_get_group(RustError, RustSlice*);
+bool skylight_error_get_description(RustError, RustSlice*);
+bool skylight_error_get_details(RustError, RustSlice*);
+bool skylight_error_set_details(RustError, RustSlice);
+bool skylight_error_serialize_into_new_buffer(RustError, RustString*);
+
+void skylight_free_buf(RustString);
+
+#endif

data/ext/skylight_native.c

@@ -1,5 +1,5 @@
+#include <skylight.h>
 #include <ruby.h>
-#include <stdbool.h>
 
 #ifdef HAVE_RUBY_ENCODING_H
 #include <ruby/encoding.h>
@@ -49,104 +49,50 @@
   }                                               \
 
 #define CHECK_FFI(success, message)               \
-  {                                               \
+  ({                                              \
     if (!(success))                               \
       rb_raise(rb_eRuntimeError, message);        \
-  }                                               \
-
-/**
- * Rust types
- */
-
-typedef struct {
-  size_t fill;    // in bytes; if zero, heapified
-  size_t alloc;   // in bytes
-  uint8_t data[0];
-} rust_str;
-
-typedef struct {
-  char * data;
-  long len;
-} RustSlice;
-
-typedef rust_str * RustString;
-typedef RustString RustVector;
-#define VEC2STR(vector) ({ RustVector v = (vector); VALUE ret = rb_str_new((char *)v->data, v->fill); ret; })
-#define SLICE2STR(slice) ({ RustSlice s = (slice); VALUE str = rb_str_new(s.data, s.len); rb_enc_associate(str, rb_utf8_encoding()); str; })
-#define STR2SLICE(string) ({ RustSlice s; VALUE rb_str = (string); s.data = RSTRING_PTR(rb_str); s.len = RSTRING_LEN(rb_str); s; })
-
-#define UnwrapOption(T, val, transform) ({ T * v = (val); VALUE ret; if (v == NULL) ret = Qnil; else ret = transform(*v); ret; })
-
-typedef struct {
-  uint8_t discrim;
-  RustSlice slice;
-} OptionRustSlice;
+  })
+
+#define VEC2STR(vector)                               \
+  ({                                                  \
+    RustVector v = (vector);                          \
+    VALUE ret = rb_str_new((char *)v->data, v->fill); \
+    ret;                                              \
+  })
+
+#define SLICE2STR(slice)                        \
+  ({                                            \
+    RustSlice s = (slice);                      \
+    VALUE str = rb_str_new(s.data, s.len);      \
+    rb_enc_associate(str, rb_utf8_encoding());  \
+    str;                                        \
+  })
+
+#define STR2SLICE(string)         \
+  ({                              \
+    RustSlice s;                  \
+    VALUE rb_str = (string);      \
+    s.data = RSTRING_PTR(rb_str); \
+    s.len = RSTRING_LEN(rb_str);  \
+    s;                            \
+  })
+
+#define UnwrapOption(T, val, transform) \
+  ({                                    \
+    T * v = (val);                      \
+    VALUE ret;                          \
+    if (v == NULL) {                    \
+      ret = Qnil;                       \
+    }                                   \
+    else {                              \
+      ret = transform(*v);              \
+    }                                   \
+    ret;                                \
+  })
 
 #define IsNone(val) val.discrim == 0
 
-/**
- * Externed Rust functions from libskylight
- */
-
-typedef void * RustHello;
-typedef void * RustError;
-typedef void * RustTrace;
-typedef void * RustBatch;
-
-void factory();
-
-
-// Rust skylight_hello prototypes
-bool skylight_hello_new(RustSlice, uint32_t, RustHello*);
-bool skylight_hello_free(RustHello);
-bool skylight_hello_load(RustSlice, RustHello*);
-bool skylight_hello_cmd_add(RustHello, RustSlice);
-bool skylight_hello_get_version(RustHello, RustSlice*);
-bool skylight_hello_cmd_length(RustHello, uint32_t*);
-bool skylight_hello_get_cmd(RustHello, int, RustSlice*);
-bool skylight_hello_serialize_into_new_buffer(RustHello, RustString*);
-bool skylight_high_res_time(uint64_t*);
-
-// Rust skylight_trace prototypes
-bool skylight_trace_new(uint64_t, RustSlice, RustTrace*);
-bool skylight_trace_free(RustTrace);
-bool skylight_trace_load(RustSlice, RustTrace*);
-bool skylight_trace_name_from_serialized_into_new_buffer(RustSlice, RustString*);
-bool skylight_trace_get_started_at(RustTrace, uint64_t*);
-bool skylight_trace_set_name(RustTrace, RustSlice);
-bool skylight_trace_get_name(RustTrace, RustSlice*);
-bool skylight_trace_get_uuid(RustTrace, RustSlice*);
-bool skylight_trace_start_span(RustTrace, uint64_t, RustSlice, uint32_t*);
-bool skylight_trace_stop_span(RustTrace, uint32_t, uint64_t);
-bool skylight_trace_serialize_into_new_buffer(RustTrace, RustString*);
-bool skylight_trace_span_set_title(RustTrace, uint64_t, RustSlice);
-bool skylight_trace_span_set_description(RustTrace, uint64_t, RustSlice);
-
-// Trace annotation methods
-bool skylight_trace_add_annotation_int(RustTrace, uint32_t, uint32_t*, RustSlice*, int64_t);
-bool skylight_trace_add_annotation_double(RustTrace, uint32_t, uint32_t*, RustSlice*, double);
-bool skylight_trace_add_annotation_string(RustTrace, uint32_t, uint32_t*, RustSlice*, RustSlice);
-bool skylight_trace_add_annotation_nested(RustTrace, uint32_t, uint32_t*, RustSlice*, uint32_t*);
-
-// Batch methods
-bool skylight_batch_new(uint32_t, RustString, RustBatch*);
-bool skylight_batch_free(RustBatch);
-bool skylight_batch_set_endpoint_count(RustBatch, RustSlice, uint64_t);
-bool skylight_batch_move_in(RustBatch, RustString);
-bool skylight_batch_serialize_into_new_buffer(RustBatch, RustString*);
-
-// Error methods
-bool skylight_error_new(RustSlice, RustSlice, RustError*);
-bool skylight_error_free(RustError);
-bool skylight_error_load(RustSlice, RustError*);
-bool skylight_error_get_group(RustError, RustSlice*);
-bool skylight_error_get_description(RustError, RustSlice*);
-bool skylight_error_get_details(RustError, RustSlice*);
-bool skylight_error_set_details(RustError, RustSlice);
-bool skylight_error_serialize_into_new_buffer(RustError, RustString*);
-
-void skylight_free_buf(RustString);
-
 /**
  * Convert Ruby String to a Rust String
  */
@@ -154,7 +100,13 @@ void skylight_free_buf(RustString);
 RustString skylight_slice_to_owned(RustSlice);
 RustString skylight_bytes_to_new_vec(uint8_t*, uint64_t);
 
-#define STR2RUST(string) ({ VALUE rb_str = (string); skylight_bytes_to_new_vec((uint8_t*)RSTRING_PTR(rb_str), RSTRING_LEN(rb_str)); })
+#define STR2RUST(string)              \
+  ({                                  \
+    VALUE rb_str = (string);          \
+    skylight_bytes_to_new_vec(        \
+      (uint8_t*) RSTRING_PTR(rb_str), \
+      RSTRING_LEN(rb_str));           \
+  })
 
 /**
  * Ruby types defined here

data/lib/skylight.rb

@@ -2,25 +2,32 @@ require 'rbconfig'
 require 'socket'
 require 'skylight/version'
 
-begin
-  unless ENV["SKYLIGHT_DISABLE_AGENT"]
-    require 'skylight_native'
-    require 'skylight/native'
-    has_native_ext = true
-  end
-rescue LoadError
-  if defined?(Rails) && !Rails.env.development? && !Rails.env.test?
-    puts "[SKYLIGHT] [#{Skylight::VERSION}] The Skylight native extension for your platform wasn't found. We currently support monitoring in 32- and 64-bit Linux only. If you are on a supported platform, please contact support at support@skylight.io. The missing extension will not affect the functioning of your application."
-  elsif defined?(Rails)
-    puts "[SKYLIGHT] [#{Skylight::VERSION}] Running Skylight in #{Rails.env} mode. No data will be reported until you deploy your app."
-  else
-    puts "[SKYLIGHT] [#{Skylight::VERSION}] Running Skylight in development mode."
-  end
-  raise if ENV.key?("SKYLIGHT_REQUIRED")
-end
-
 module Skylight
   TRACE_ENV_KEY      = 'SKYLIGHT_ENABLE_TRACE_LOGS'.freeze
+  STANDALONE_ENV_KEY = 'SKYLIGHT_STANDALONE'.freeze
+  STANDALONE_ENV_VAL = 'server'.freeze
+
+  # Whether or not the native extension is present
+  @@has_native_ext = false
+
+  def self.native?
+    @@has_native_ext
+  end
+
+  begin
+    unless ENV["SKYLIGHT_DISABLE_AGENT"]
+      # First attempt to require the native extension
+      require 'skylight_native'
+
+      # If nothing was thrown, then the native extension is present
+      @@has_native_ext = true
+
+      # Require ruby support for the native extension
+      require 'skylight/native'
+    end
+  rescue LoadError
+    raise if ENV.key?("SKYLIGHT_REQUIRED")
+  end
 
   autoload :Api,          'skylight/api'
   autoload :CLI,          'skylight/cli'
@@ -42,16 +49,16 @@ module Skylight
   if defined?(Rails)
     require 'skylight/railtie'
   end
-end
-
-if has_native_ext
 
-module Skylight
-  STANDALONE_ENV_KEY = 'SKYLIGHT_STANDALONE'.freeze
-  STANDALONE_ENV_VAL = 'server'.freeze
-
-  def self.native?
-    true
+  def self.warn_skylight_native_missing
+    # TODO: Dumping the error messages this way is pretty hacky
+    if defined?(Rails) && !Rails.env.development? && !Rails.env.test?
+      puts "[SKYLIGHT] [#{Skylight::VERSION}] The Skylight native extension for your platform wasn't found. We currently support monitoring in 32- and 64-bit Linux only. If you are on a supported platform, please contact support at support@skylight.io. The missing extension will not affect the functioning of your application."
+    elsif defined?(Rails)
+      puts "[SKYLIGHT] [#{Skylight::VERSION}] Running Skylight in #{Rails.env} mode. No data will be reported until you deploy your app."
+    else
+      puts "[SKYLIGHT] [#{Skylight::VERSION}] Running Skylight in development mode."
+    end
   end
 
   def self.daemon?
@@ -103,6 +110,12 @@ module Skylight
   DEFAULT_CATEGORY = "app.block".freeze
   DEFAULT_OPTIONS = { category: DEFAULT_CATEGORY }
 
+  #
+  #
+  # ===== Public API =====
+  #
+  #
+
   def self.start!(*args)
     Instrumenter.start!(*args)
   end
@@ -136,7 +149,7 @@ module Skylight
     end
 
     if Hash === opts
-      category = opts.delete(:category)
+      category = opts.delete(:category) || DEFAULT_CATEGORY
       title    = opts.delete(:title)
       desc     = opts.delete(:description)
     else
@@ -170,34 +183,3 @@ module Skylight
 
   require 'skylight/probes'
 end
-
-else
-
-module Skylight
-  def self.native?
-    false
-  end
-
-  def self.start!(*)
-  end
-
-  def self.stop!(*)
-  end
-
-  def self.trace(*)
-    yield if block_given?
-  end
-
-  def self.done(*)
-  end
-
-  def self.instrument(*)
-    yield if block_given?
-  end
-
-  def self.disable(*)
-    yield if block_given?
-  end
-end
-
-end

data/lib/skylight/instrumenter.rb

@@ -1,6 +1,7 @@
 require 'thread'
 require 'set'
 require 'base64'
+require 'strscan'
 
 module Skylight
   class Instrumenter
@@ -70,6 +71,11 @@ module Skylight
     def start!
       return unless config
 
+      unless Skylight.native?
+        Skylight.warn_skylight_native_missing
+        return
+      end
+
       t { "starting instrumenter" }
       @config.validate!
 
@@ -153,6 +159,8 @@ module Skylight
     end
 
     def instrument(cat, title=nil, desc=nil, annot=nil)
+      raise ArgumentError, 'cat is required' unless cat
+
       unless trace = @trace_info.current
         return yield if block_given?
         return

data/lib/skylight/native.rb

@@ -1,80 +1,83 @@
 module Skylight
-  class Hello
-    DIGITS = /^\s*\d+\s*$/
 
-    alias serialize native_serialize
-    alias version native_get_version
+  if native?
+    class Hello
+      DIGITS = /^\s*\d+\s*$/
 
-    class << self
-      alias deserialize native_load
-    end
+      alias serialize native_serialize
+      alias version native_get_version
 
-    def cmd
-      native_cmd_length.times.map do |offset|
-        native_cmd_get(offset)
+      class << self
+        alias deserialize native_load
       end
-    end
 
-    def newer?(other = VERSION)
-      other = split(other)
-      curr  = split(version)
+      def cmd
+        native_cmd_length.times.map do |offset|
+          native_cmd_get(offset)
+        end
+      end
 
-      [other.length, curr.length].max.times do |i|
-        next if other[i] == curr[i]
-        return true unless other[i]
+      def newer?(other = VERSION)
+        other = split(other)
+        curr  = split(version)
 
-        if other[i] =~ DIGITS
-          if curr[i] =~ DIGITS
-            other_i = other[i].to_i
-            curr_i = curr[i].to_i
+        [other.length, curr.length].max.times do |i|
+          next if other[i] == curr[i]
+          return true unless other[i]
 
-            next if other_i == curr_i
+          if other[i] =~ DIGITS
+            if curr[i] =~ DIGITS
+              other_i = other[i].to_i
+              curr_i = curr[i].to_i
 
-            return curr_i > other_i
-          else
-            return false
-          end
-        else
-          if curr[i] =~ DIGITS
-            return true
+              next if other_i == curr_i
+
+              return curr_i > other_i
+            else
+              return false
+            end
           else
-            next if curr[i] == other[i]
-            return curr[i] > other[i]
+            if curr[i] =~ DIGITS
+              return true
+            else
+              next if curr[i] == other[i]
+              return curr[i] > other[i]
+            end
           end
         end
-      end
 
-      false
-    end
+        false
+      end
 
-    private
+      private
 
-      def split(v)
-        v.split('.')
-      end
+        def split(v)
+          v.split('.')
+        end
 
-  end
+    end
 
-  class Error
-    alias serialize native_serialize
-    alias type native_get_group
-    alias description native_get_description
-    alias details native_get_details
+    class Error
+      alias serialize native_serialize
+      alias type native_get_group
+      alias description native_get_description
+      alias details native_get_details
 
-    class << self
-      alias deserialize native_load
+      class << self
+        alias deserialize native_load
+      end
     end
-  end
 
-  class Trace
-    alias serialize native_serialize
+    class Trace
+      alias serialize native_serialize
 
-    class << self
-      alias deserialize native_load
+      class << self
+        alias deserialize native_load
+      end
     end
-  end
 
-  class Batch
-    alias serialize native_serialize
+    class Batch
+      alias serialize native_serialize
+    end
   end
 end

data/lib/skylight/probes.rb

@@ -39,6 +39,8 @@ module Skylight
     end
 
     def self.require_hook(require_path)
+      return unless Skylight.native?
+
       registration = lookup_by_require_path(require_path)
       return unless registration
 

data/lib/skylight/util/clock.rb

@@ -6,8 +6,16 @@ module Skylight
         Time.now.to_i
       end
 
-      def nanos
-        native_hrtime
+      if Skylight.native?
+        def nanos
+          native_hrtime
+        end
+      else
+        # Implement nanos to work when native extension is not present
+        def nanos
+          now = Time.now
+          now.to_i * 1_000_000_000 + now.usec * 1_000
+        end
       end
 
       def secs

data/lib/skylight/util/native_ext_fetcher.rb

@@ -0,0 +1,195 @@
+require 'uri'
+require 'logger'
+require 'zlib'
+require 'net/http'
+require 'digest/sha2'
+
+# Must require 'rubygems/platform' vs. just requiring 'rubygems' to avoid a
+# stack overflow bug on ruby 1.9.2.
+require 'rubygems/platform'
+
+module Skylight
+  module Util
+    class NativeExtFetcher
+      BASE_URL = "https://github.com/skylightio/skylight-rust/releases/download"
+      MAX_REDIRECTS = 5
+      MAX_RETRIES = 3
+
+      class FetchError < StandardError; end
+
+      def self.fetch(opts = {})
+        platform = Gem::Platform.local
+
+        fetcher = new(
+          BASE_URL,
+          opts[:target],
+          opts[:version],
+          opts[:checksums],
+          opts[:cpu] || platform.cpu,
+          opts[:os] || platform.os,
+          opts[:required],
+          opts[:logger] || Logger.new(STDOUT))
+
+        fetcher.fetch
+      end
+
+      def initialize(source, target, version, checksums, cpu, os, required, log)
+        raise "source required" unless source
+        raise "checksums required" unless checksums
+        raise "cpu required" unless cpu
+        raise "os required" unless os
+
+        @source = source
+        @target = target
+        @version = version
+        @checksums = checksums
+        @required = required
+        @arch = "#{os}-#{cpu}"
+        @log = log
+      end
+
+      def fetch
+        # Ensure that the requested arch is valid
+        unless @checksums[@arch]
+          maybe_raise "no checksum entry for requested architecture -- " \
+            "this probably means the requested architecture is not supported; " \
+            "arch=#{@arch}; available=#{@checksums.keys}"
+          return
+        end
+
+        log "fetching native ext; curr-platform=#{Gem::Platform.local.to_s}; " \
+          "requested-arch=#{@arch}; version=#{@version}"
+
+        unless gziped = fetch_native_ext(source_uri, MAX_RETRIES, MAX_REDIRECTS)
+          maybe_raise "could not fetch native extension"
+          return
+        end
+
+        unless verify_checksum(gziped)
+          maybe_raise "could not verify checksum"
+          return
+        end
+
+        archive = inflate(gziped)
+
+        if @target
+          File.open @target, 'w' do |f|
+            f.write(archive)
+          end
+        end
+
+        archive
+      end
+
+      def self.http_get(host, port, use_ssl, path)
+        Net::HTTP.start(host, port, use_ssl: use_ssl) do |http|
+          case response = http.get(path)
+          when Net::HTTPSuccess
+            return [ :success, response.body ]
+          when Net::HTTPRedirection
+            unless location = response['location']
+              raise "received redirect but no location"
+            end
+
+            return [ :redirect, location ]
+          else
+            raise "received HTTP status code #{response.code}"
+          end
+        end
+      end
+
+      def fetch_native_ext(uri, attempts, redirects)
+        redirects.times do |i|
+          remaining_attempts = attempts
+
+          log "attempting to fetch from remote; uri=#{uri}"
+
+          begin
+            host, port, use_ssl, path = deconstruct_uri(uri)
+
+            status, body = NativeExtFetcher.http_get(host, port, use_ssl, path)
+
+            case status
+            when :success
+              if body
+                log "successfully downloaded native ext; body=#{body.bytesize}bytes"
+              else
+                log "response did not contain a body"
+              end
+
+              return body
+            when :redirect
+              log "fetching native ext; uri=#{uri}; redirected=#{body}"
+              uri = body
+
+              next
+            else
+              raise "received unknown return; status=#{status}; body=#{body}"
+            end
+
+          rescue => e
+            remaining_attempts -= 1
+
+            log "failed to fetch native extension; uri=#{uri}; msg=#{e.message}; remaining-attempts=#{remaining_attempts}", e
+
+            if remaining_attempts > 0
+              sleep 2
+              retry
+            end
+
+            return
+          end
+        end
+
+        log "exceeded max redirects"
+        return
+      end
+
+      def verify_checksum(archive)
+        unless expected = @checksums[@arch]
+          log "no checksum provided; arch=#{@arch}"
+          return false
+        end
+
+        actual = Digest::SHA2.hexdigest(archive)
+
+        unless expected == actual
+          log "checksum mismatch; expected=#{expected}; actual=#{actual}"
+          return false
+        end
+
+        true
+      end
+
+      def inflate(archive)
+        inflater = Zlib::Inflate.new(32 + Zlib::MAX_WBITS)
+        inflated = inflater.inflate(archive)
+        inflater.close
+        inflated
+      end
+
+      def source_uri
+        "#{@source}/#{@version}/libskylight.#{@arch}.a.gz"
+      end
+
+      def deconstruct_uri(uri)
+        uri = URI(uri)
+        [ uri.host, uri.port, uri.scheme == 'https', uri.request_uri ]
+      end
+
+      def maybe_raise(err)
+        log err
+
+        if @required
+          raise err
+        end
+      end
+
+      def log(msg, e = nil)
+        msg = "[SKYLIGHT] #{msg}"
+        msg << "\n#{e.backtrace.join("\n")}" if e
+        @log.info msg
+      end
+    end
+  end
+end

data/lib/skylight/version.rb

@@ -1,4 +1,4 @@
 module Skylight
-  VERSION = '0.3.6'
+  VERSION = '0.3.7'
 end
 

metadata

@@ -1,27 +1,27 @@
 --- !ruby/object:Gem::Specification
 name: skylight
 version: !ruby/object:Gem::Version
-  version: 0.3.6
+  version: 0.3.7
 platform: ruby
 authors:
 - Tilde, Inc.
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-27 00:00:00.000000000 Z
+date: 2014-04-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: 3.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: 3.0.0
 description: 
@@ -33,13 +33,6 @@ extensions:
 - ext/extconf.rb
 extra_rdoc_files: []
 files:
-- CHANGELOG.md
-- README.md
-- bin/skylight
-- ext/checksums.yml
-- ext/extconf.rb
-- ext/skylight.map
-- ext/skylight_native.c
 - lib/skylight.rb
 - lib/skylight/api.rb
 - lib/skylight/cli.rb
@@ -78,6 +71,7 @@ files:
 - lib/skylight/util/http.rb
 - lib/skylight/util/inflector.rb
 - lib/skylight/util/logging.rb
+- lib/skylight/util/native_ext_fetcher.rb
 - lib/skylight/util/queue.rb
 - lib/skylight/util/task.rb
 - lib/skylight/util/uniform_sample.rb
@@ -139,6 +133,14 @@ files:
 - lib/sql_lexer.rb
 - lib/sql_lexer/lexer.rb
 - lib/sql_lexer/version.rb
+- ext/skylight.h
+- ext/skylight_native.c
+- ext/skylight.map
+- ext/extconf.rb
+- ext/libskylight.yml
+- CHANGELOG.md
+- README.md
+- bin/skylight
 homepage: http://www.skylight.io
 licenses: []
 metadata: {}
@@ -148,17 +150,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - '>='
     - !ruby/object:Gem::Version
       version: 1.9.2
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.1
+rubygems_version: 2.0.3
 signing_key: 
 specification_version: 4
 summary: Skylight is a ruby application monitoring tool. Currently in closed beta.

data/ext/checksums.yml

@@ -1,3 +0,0 @@
----
-x86_64-linux: "98b04f7d73c1894cc79621a135b4598a679c421f5ff3eecc652f84ba07258d9c"
-i686-linux  : "1d4bbd58e319237b18752607d087ce0c895fe99c58482e994abe62a9f07d41dd"