skylight 0.3.13 → 0.3.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7e55c1c2dc7308e528ed6b70c50bc46ded112deb
-  data.tar.gz: b1cfa59af5c1b1b1c453c6cccefc8d3f7d83a031
+  metadata.gz: 5620862e4260060cc2887d5fa2e902eeb96af51a
+  data.tar.gz: 8e664fcdf47316d921921b96286c8b336f6c0892
 SHA512:
-  metadata.gz: 902ff0813ae73c280619f70728b2669cb17bb249abab8e5f7508893d81f9cd1ab25b2d6b9d4a4203080175934c63d8a48f37fe3199d8df384269d7fc7cf590ba
-  data.tar.gz: be41caa2f4ad1c66bfb779c1d0b851cc21388d63a17153b4c3c5c2ac216209d72b302b5e7d114a3df7968041592cdb392b87f2bc389083cb2115e4757921b2b2
+  metadata.gz: 0ad66490a91813115f262f0c1640a0a50839bd82f0a81fb32952cd03fede4a742ed220db5d14491b1fda95b0217a5ff3ec48e3ddff6d77a9f4674f4dbf45bae1
+  data.tar.gz: 122849003b5c4d135c8244d37e65ca1505a8cb421ff874c7d6e1af180e8fe122026155c734645ccf10a7527ad1182fe19cf64d9bab3ad2f0b13a1aa44b103c5b

data/CHANGELOG.md

@@ -1,3 +1,10 @@
+## 0.3.14 (June 3, 2014)
+
+* Do not build C extension if dependencies (libraries/headers) are
+  missing
+* [RUST] Improve performance by not double copying memory when serializing
+* Enable the Net::HTTP probe by default
+
 ## 0.3.13 (May 12, 2014)
 
 * Load probes even when agent is disabled

data/ext/extconf.rb

@@ -104,7 +104,8 @@ end
 
 have_header 'dlfcn.h'
 
-find_library("skylight", "factory", ".")
+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"
 
 $CFLAGS << " -Werror"
 if RbConfig::CONFIG["arch"] =~ /darwin(\d+)?/
@@ -116,4 +117,4 @@ end
 
 CONFIG['warnflags'].gsub!('-Wdeclaration-after-statement', '')
 
-create_makefile 'skylight_native', '.'
+create_makefile 'skylight_native', '.' or fail "could not create makefile"

data/ext/libskylight.yml

@@ -1,6 +1,6 @@
 ---
-version: "f2a0e15"
+version: "dfa09f3"
 checksums:
-  linux-x86_64: "a99d5542893418b0a5b6b53a599b2c2a07dc8186491181f6dbe0ccfab03dbed4"
-  linux-x86: "a4db4dfbaaa1181e74e6756f4d56ba00fdf4b88e54476294086e7e27bf0c3cdc"
+  linux-x86_64: "be6c610564c66e2a098e7c22226ac879cc970bac252b2534a11b556197f2efca"
+  linux-x86: "2113e80b8afddf5f00c81590c8cbcfbb6ecaf9dbdec950eca06bb11ed1456351"
 

data/ext/rust_support/ruby.h

@@ -0,0 +1,93 @@
+#ifndef __RUST_H__
+#define __RUST_H__
+
+#include <stddef.h>
+#include <stdint.h>
+#include <stdbool.h>
+
+/**
+ * Rust types
+ */
+
+typedef struct {
+  char* data;
+  long len;
+} RustSlice;
+
+typedef void* RustVec;
+typedef void* RustString;
+
+bool rust_string_as_slice(RustString, RustSlice*);
+
+#define TO_S(VAL) \
+  RSTRING_PTR(rb_funcall(VAL, rb_intern("to_s"), 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 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_FFI(success, message)               \
+  ({                                              \
+    if (!(success))                               \
+      rb_raise(rb_eRuntimeError, message);        \
+  })
+
+#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 RUSTSTR2STR(string)          \
+  ({                                 \
+    RustString s = (string);         \
+    RustSlice slice;                  \
+    CHECK_FFI(rust_string_as_slice(s, &slice), "Couldn't convert String to &str"); \
+    SLICE2STR(slice);                    \
+  })
+
+#endif
+
+#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);        \
+  }

data/ext/skylight.h

@@ -5,33 +5,27 @@
 #include <stdint.h>
 #include <stdbool.h>
 
+#include <rust_support/ruby.h>
+
 /**
- * Rust types
+ * TODO: This is copied from rust_support
  */
 
-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;
+bool skylight_string_as_slice(RustString, RustSlice*);
 
-typedef struct {
-  uint8_t discrim;
-  RustSlice slice;
-} OptionRustSlice;
-
-typedef rust_str * RustString;
-typedef RustString RustVector;
+#define SKYLIGHT_RUSTSTR2STR(string)          \
+  ({                                 \
+    RustString s = (string);         \
+    RustSlice slice;                  \
+    CHECK_FFI(skylight_string_as_slice(s, &slice), "Couldn't convert String to &str"); \
+    SLICE2STR(slice);                    \
+  })
 
 /**
  * Externed Rust functions from libskylight
  */
 
+typedef void * RustSerializer;
 typedef void * RustHello;
 typedef void * RustError;
 typedef void * RustTrace;
@@ -46,8 +40,9 @@ 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_hello_get_cmd(RustHello, uint32_t, RustSlice*);
+bool skylight_hello_get_serializer(RustHello, RustSerializer*);
+bool skylight_hello_serialize(RustHello, RustSerializer, RustSlice);
 bool skylight_high_res_time(uint64_t*);
 
 // Rust skylight_trace prototypes
@@ -60,22 +55,18 @@ 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*);
+bool skylight_trace_get_serializer(RustTrace, RustSerializer*);
+bool skylight_trace_serialize(RustTrace, RustSerializer, RustSlice);
 
 // Batch methods
-bool skylight_batch_new(uint32_t, RustString, RustBatch*);
+bool skylight_batch_new(uint32_t, RustSlice*, 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*);
+bool skylight_batch_move_in(RustBatch, RustSlice);
+bool skylight_batch_get_serializer(RustBatch, RustSerializer*);
+bool skylight_batch_serialize(RustBatch, RustSerializer, RustSlice);
 
 // Error methods
 bool skylight_error_new(RustSlice, RustSlice, RustError*);
@@ -85,8 +76,10 @@ 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*);
+bool skylight_error_get_serializer(RustError, RustSerializer*);
+bool skylight_error_serialize(RustError, RustSerializer, RustSlice);
 
-void skylight_free_buf(RustString);
+bool skylight_serializer_get_serialized_size(RustSerializer, size_t*);
+bool skylight_serializer_free(RustSerializer);
 
 #endif

data/ext/skylight_native.c

@@ -9,104 +9,27 @@
  * Ruby helpers
  */
 
-#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 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);        \
-  }                                               \
-
-#define CHECK_FFI(success, message)               \
-  ({                                              \
-    if (!(success))                               \
-      rb_raise(rb_eRuntimeError, message);        \
-  })
-
-#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
-
-/**
- * Convert Ruby String to a Rust String
- */
-
-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 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;                                                                                                                   \
   })
 
 /**
@@ -189,7 +112,7 @@ static VALUE hello_add_cmd_part(VALUE self, VALUE rb_string) {
 }
 
 static VALUE hello_cmd_get(VALUE self, VALUE rb_off) {
-  int off;
+  uint32_t off;
   RustSlice slice;
   My_Struct(hello, RustHello, freedHello);
 
@@ -202,15 +125,8 @@ static VALUE hello_cmd_get(VALUE self, VALUE rb_off) {
 }
 
 static VALUE hello_serialize(VALUE self) {
-  RustString serialized;
   Transfer_My_Struct(hello, RustHello, freedHello);
-
-  CHECK_FFI(skylight_hello_serialize_into_new_buffer(hello, &serialized), "Could not serialize Hello");
-  skylight_hello_free(hello);
-
-  VALUE string = VEC2STR(serialized);
-  skylight_free_buf(serialized);
-  return string;
+  return SERIALIZE(hello);
 }
 
 /**
@@ -281,15 +197,8 @@ static VALUE error_set_details(VALUE self, VALUE details) {
 }
 
 static VALUE error_serialize(VALUE self) {
-  RustString serialized;
   Transfer_My_Struct(error, RustError, freedError);
-
-  CHECK_FFI(skylight_error_serialize_into_new_buffer(error, &serialized), "Could not serialize Error");
-  skylight_error_free(error);
-
-  VALUE string = VEC2STR(serialized);
-  skylight_free_buf(serialized);
-  return string;
+  return SERIALIZE(error);
 }
 
 /**
@@ -316,9 +225,7 @@ static VALUE trace_name_from_serialized(VALUE self, VALUE protobuf) {
 
   CHECK_FFI(skylight_trace_name_from_serialized_into_new_buffer(STR2SLICE(protobuf), &trace_name), "Could not read name from serialized Trace");
 
-  VALUE ret = VEC2STR(trace_name);
-  skylight_free_buf(trace_name);
-  return ret;
+  return SKYLIGHT_RUSTSTR2STR(trace_name);
 }
 
 static VALUE trace_get_started_at(VALUE self) {
@@ -348,8 +255,6 @@ static VALUE trace_get_name(VALUE self) {
   } else {
     return Qnil;
   }
-
-  //return UnwrapOption(RustSlice, skylight_trace_get_name(trace), SLICE2STR);
 }
 
 static VALUE trace_get_uuid(VALUE self) {
@@ -408,15 +313,7 @@ static VALUE trace_span_set_description(VALUE self, VALUE index, VALUE descripti
 
 static VALUE trace_serialize(VALUE self) {
   Transfer_My_Struct(trace, RustTrace, freedTrace);
-
-  RustString string;
-
-  CHECK_FFI(skylight_trace_serialize_into_new_buffer(trace, &string), "Could not serialize Trace");
-  skylight_trace_free(trace);
-
-  VALUE rb_string = VEC2STR(string);
-  skylight_free_buf(string);
-  return rb_string;
+  return SERIALIZE(trace);
 }
 
 /**
@@ -428,12 +325,15 @@ static const char* freedBatch = "You can't do anything with a Batch once it's be
 VALUE batch_new(VALUE klass, VALUE rb_timestamp, VALUE rb_hostname) {
   CHECK_NUMERIC(rb_timestamp);
 
-  RustString hostname = NULL;
+  RustSlice* hostname = NULL;
+  RustSlice tmp;
+
   uint32_t timestamp = (uint32_t) NUM2ULONG(rb_timestamp);
 
   if (rb_hostname != Qnil) {
     CHECK_TYPE(rb_hostname, T_STRING);
-    hostname = STR2RUST(rb_hostname);
+    tmp = STR2SLICE(rb_hostname);
+    hostname = &tmp;
   }
 
   RustBatch batch;
@@ -459,22 +359,14 @@ VALUE batch_move_in(VALUE self, VALUE rb_string) {
 
   My_Struct(batch, RustBatch, freedBatch);
 
-  CHECK_FFI(skylight_batch_move_in(batch, STR2RUST(rb_string)), "Could not add serialized Trace to Batch");
+  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);
-
-  RustString string;
-
-  CHECK_FFI(skylight_batch_serialize_into_new_buffer(batch, &string), "Could not serialize Batch");
-  skylight_batch_free(batch);
-
-  VALUE rb_string = VEC2STR(string);
-  skylight_free_buf(string);
-  return rb_string;
+  return SERIALIZE(batch);
 }
 
 void Init_skylight_native() {

data/ext/test/extconf.rb

@@ -0,0 +1,18 @@
+require 'mkmf'
+
+have_header 'dlfcn.h'
+
+find_header("rust_support/ruby.h", "..") || abort("No rust_support")
+find_library("skylight_test", "skylight_test_factory", ".") || abort("No skylight_test")
+
+$CFLAGS << " -Werror"
+if RbConfig::CONFIG["arch"] =~ /darwin(\d+)?/
+  $LDFLAGS << " -lpthread"
+else
+  $LDFLAGS << " -Wl"
+  $LDFLAGS << " -lrt -ldl -lm -lpthread"
+end
+
+CONFIG['warnflags'].gsub!('-Wdeclaration-after-statement', '')
+
+create_makefile 'skylight_native_test', '.'

data/ext/test/skylight_native_test.c

@@ -0,0 +1,82 @@
+#include <ruby.h>
+#include "skylight_test.h"
+
+#ifdef HAVE_RUBY_ENCODING_H
+#include <ruby/encoding.h>
+#endif
+
+VALUE rb_mSkylightTest;
+VALUE rb_mNumeric;
+VALUE rb_mStrings;
+VALUE rb_mStructs;
+VALUE rb_cPerson;
+
+static VALUE numeric_multiply(VALUE klass, VALUE a, VALUE b) {
+  CHECK_NUMERIC(a);
+  CHECK_NUMERIC(b);
+
+  uint64_t ret;
+
+  CHECK_FFI(skylight_test_numeric_multiply(NUM2ULL(a), NUM2ULL(b), &ret), "could not multiply");
+
+  return ULL2NUM(ret);
+}
+
+static VALUE strings_multiple(VALUE klass, VALUE input) {
+  CHECK_TYPE(input, T_STRING);
+
+  RustString string;
+
+  CHECK_FFI(skylight_test_strings_reverse(STR2SLICE(input), &string), "could not reverse");
+
+  return RUSTSTR2STR(string);
+}
+
+static const char* freedPerson = "You can't do anything with a Person once it is freed";
+
+static VALUE person_new(VALUE klass, VALUE name, VALUE age) {
+  CHECK_TYPE(name, T_STRING);
+  CHECK_NUMERIC(age);
+
+  RustPerson person;
+
+  CHECK_FFI(skylight_test_person_new(STR2SLICE(name), NUM2ULL(age), &person), "could not create new Person");
+
+  return Data_Wrap_Struct(rb_cPerson, NULL, skylight_test_person_free, person);
+}
+
+static VALUE person_get_name(VALUE self) {
+  My_Struct(person, RustPerson, freedPerson);
+
+  RustSlice name;
+
+  CHECK_FFI(skylight_test_person_get_name(person, &name), "could not get person name");
+
+  return SLICE2STR(name);
+}
+
+static VALUE person_get_age(VALUE self) {
+  My_Struct(person, RustPerson, freedPerson);
+
+  uint64_t age;
+
+  CHECK_FFI(skylight_test_person_get_age(person, &age), "could not get person age");
+
+  return ULL2NUM(age);
+}
+
+void Init_skylight_native_test() {
+  rb_mSkylightTest = rb_define_module("SkylightTest");
+  rb_mNumeric = rb_define_module_under(rb_mSkylightTest, "Numeric");
+  rb_mStrings = rb_define_module_under(rb_mSkylightTest, "Strings");
+  rb_mStructs = rb_define_module_under(rb_mSkylightTest, "Structs");
+  rb_cPerson = rb_define_class_under(rb_mStructs, "Person", rb_cObject);
+  
+  rb_define_singleton_method(rb_mNumeric, "multiply", numeric_multiply, 2);
+
+  rb_define_singleton_method(rb_mStrings, "reverse", strings_multiple, 1);
+
+  rb_define_singleton_method(rb_cPerson, "new", person_new, 2);
+  rb_define_method(rb_cPerson, "name", person_get_name, 0);
+  rb_define_method(rb_cPerson, "age", person_get_age, 0);
+}

data/ext/test/skylight_test.h

@@ -0,0 +1,20 @@
+#ifndef __SKYLIGHT_TEST_H__
+#define __SKYLIGHT_TEST_H__
+
+#include <stddef.h>
+#include <stdint.h>
+#include <stdbool.h>
+
+#include <rust_support/ruby.h>
+
+typedef void * RustPerson;
+
+bool skylight_test_numeric_multiply(uint64_t, uint64_t, uint64_t*);
+bool skylight_test_strings_reverse(RustSlice, RustString*);
+
+bool skylight_test_person_new(RustSlice, uint64_t, RustPerson*);
+bool skylight_test_person_get_name(RustPerson, RustSlice*);
+bool skylight_test_person_get_age(RustPerson, uint64_t*);
+bool skylight_test_person_free(RustPerson);
+
+#endif

data/lib/skylight/railtie.rb

@@ -13,7 +13,9 @@ module Skylight
     config.skylight.config_path = "config/skylight.yml"
 
     # The probes to load
-    config.skylight.probes = []
+    #   net_http is on by default
+    #   Also available: excon
+    config.skylight.probes = ['net_http']
 
     initializer 'skylight.configure' do |app|
       # Load probes even when agent is inactive to catch probe related bugs sooner

data/lib/skylight/version.rb

@@ -1,4 +1,4 @@
 module Skylight
-  VERSION = '0.3.13'
+  VERSION = '0.3.14'
 end
 

metadata

@@ -1,27 +1,27 @@
 --- !ruby/object:Gem::Specification
 name: skylight
 version: !ruby/object:Gem::Version
-  version: 0.3.13
+  version: 0.3.14
 platform: ruby
 authors:
 - Tilde, Inc.
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-12 00:00:00.000000000 Z
+date: 2014-06-03 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,14 +33,6 @@ extensions:
 - ext/extconf.rb
 extra_rdoc_files: []
 files:
-- CHANGELOG.md
-- README.md
-- bin/skylight
-- ext/extconf.rb
-- ext/libskylight.yml
-- ext/skylight.h
-- ext/skylight.map
-- ext/skylight_native.c
 - lib/skylight.rb
 - lib/skylight/api.rb
 - lib/skylight/cli.rb
@@ -151,6 +143,18 @@ files:
 - lib/sql_lexer.rb
 - lib/sql_lexer/lexer.rb
 - lib/sql_lexer/version.rb
+- ext/rust_support/ruby.h
+- ext/skylight.h
+- ext/test/skylight_test.h
+- ext/skylight_native.c
+- ext/test/skylight_native_test.c
+- ext/skylight.map
+- ext/extconf.rb
+- ext/test/extconf.rb
+- ext/libskylight.yml
+- CHANGELOG.md
+- README.md
+- bin/skylight
 homepage: http://www.skylight.io
 licenses: []
 metadata: {}
@@ -160,19 +164,19 @@ 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.2
+rubygems_version: 2.0.3
 signing_key: 
 specification_version: 4
-summary: Skylight is a ruby application monitoring tool. Currently in closed beta.
+summary: Skylight is a smart profiler for Rails apps
 test_files: []
 has_rdoc: