truex-skylight 0.6.0

data/ext/libskylight.yml

@@ -0,0 +1,6 @@
+---
+version: "0.5.0-fbaa3ed"
+checksums:
+  x86-linux:     "926a77991c02dfb399de5bc08a39d989803f63eb4992183285e9e663df6e3c7b"
+  x86_64-linux:  "d44821e2955758d84db1f50b2c2bd0025252f67ab3d42b57e241a8a3f492dbbc"
+  x86_64-darwin: "35ac0581f439ffb66a0563f74bce957cd6ec718143a21af9f82fb5e2c43bb80e"

data/ext/skylight_memprof.c

@@ -0,0 +1,115 @@
+#include <ruby.h>
+#include <skylight_native.h>
+
+#ifdef RUBY_INTERNAL_EVENT_NEWOBJ
+
+typedef struct {
+  uint64_t allocations;
+} sky_allocations_t;
+
+#ifdef HAVE_FAST_TLS
+
+// Use the __thread directive
+static __thread sky_allocations_t sky_allocations;
+
+static inline sky_allocations_t* get_allocations() {
+  return &sky_allocations;
+}
+
+#else
+
+#include <pthread.h>
+
+// Use pthread thread locals
+static pthread_key_t ALLOCATIONS_KEY;
+
+static pthread_once_t KEY_INIT_ONCE = PTHREAD_ONCE_INIT;
+
+static void init_allocations_key() {
+  pthread_key_create(&ALLOCATIONS_KEY, free);
+}
+
+static sky_allocations_t* get_allocations() {
+  sky_allocations_t* ret;
+
+  // Initialize the TLS key
+  pthread_once(&KEY_INIT_ONCE, init_allocations_key);
+
+  ret = (sky_allocations_t*) pthread_getspecific(ALLOCATIONS_KEY);
+
+  if (ret == 0) {
+    ret = (sky_allocations_t*) malloc(sizeof(sky_allocations_t));
+    pthread_setspecific(ALLOCATIONS_KEY, (void*) ret);
+  }
+
+  return ret;
+}
+
+#endif
+
+static void sky_increment_allocation(rb_event_flag_t flag, VALUE data, VALUE self, ID mid, VALUE klass) {
+  UNUSED(flag);
+  UNUSED(data);
+  UNUSED(self);
+  UNUSED(mid);
+  UNUSED(klass);
+
+  get_allocations()->allocations++;
+}
+
+void sky_activate_memprof(void) {
+  rb_add_event_hook(sky_increment_allocation, RUBY_INTERNAL_EVENT_NEWOBJ, Qnil);
+}
+
+void sky_deactivate_memprof(void) {
+  rb_remove_event_hook(sky_increment_allocation);
+}
+
+uint64_t sky_allocation_count(void) {
+  return get_allocations()->allocations;
+}
+
+uint64_t sky_consume_allocations() {
+  uint64_t ret = get_allocations()->allocations;
+  sky_clear_allocation_count();
+  return ret;
+}
+
+void sky_clear_allocation_count(void) {
+  get_allocations()->allocations = 0;
+}
+
+int sky_have_memprof(void) {
+  return 1;
+}
+
+#else
+/*
+ *
+ * ===== No memory profiling ======
+ *
+ */
+
+void sky_activate_memprof(void) {
+}
+
+void sky_deactivate_memprof(void) {
+}
+
+uint64_t sky_allocation_count(void) {
+  return 0;
+}
+
+uint64_t sky_consume_allocations() {
+  return 0;
+}
+
+void sky_clear_allocation_count(void) {
+}
+
+int sky_have_memprof(void) {
+  return 0;
+}
+
+
+#endif

data/ext/skylight_native.c

@@ -0,0 +1,416 @@
+#include <dlfcn.h>
+#include <ruby.h>
+#include <skylight_dlopen.h>
+#include <skylight_native.h>
+
+#ifdef HAVE_RUBY_ENCODING_H
+#include <ruby/encoding.h>
+#endif
+
+#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)                                      \
+
+static inline VALUE
+BUF2STR(sky_buf_t buf) {
+  VALUE str = rb_str_new(buf.data, buf.len);
+  rb_enc_associate(str, rb_utf8_encoding());
+  return str;
+}
+
+static inline sky_buf_t
+STR2BUF(VALUE str) {
+  return (sky_buf_t) {
+    .data = RSTRING_PTR(str),
+    .len = RSTRING_LEN(str),
+  };
+}
+
+#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)          \
+  Data_Get_Struct(obj, Type, name);               \
+  if (name == NULL) {                             \
+    rb_raise(rb_eRuntimeError, "%s", msg);        \
+  }
+
+/**
+ * Ruby GVL helpers
+ */
+
+#if defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL) && \
+    defined(HAVE_RUBY_THREAD_H)
+
+// 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)
+
+// Ruby 1.9
+#elif defined(HAVE_RB_THREAD_BLOCKING_REGION)
+
+typedef VALUE (*blocking_fn_t)(void*);
+#define WITHOUT_GVL(fn, a) \
+  rb_thread_blocking_region((blocking_fn_t)(fn), (a), 0, 0)
+
+
+#endif
+
+
+/**
+ * Ruby types defined here
+ */
+
+VALUE rb_mSkylight;
+VALUE rb_mUtil;
+VALUE rb_cClock;
+VALUE rb_cTrace;
+VALUE rb_cInstrumenter;
+
+static const char* no_instrumenter_msg =
+  "Instrumenter not currently running";
+
+static const char* consumed_trace_msg =
+  "Trace objects cannot be used once it has been submitted to the instrumenter";
+
+static VALUE
+load_libskylight(VALUE klass, VALUE path) {
+  int res;
+
+  UNUSED(klass);
+  CHECK_TYPE(path, T_STRING);
+
+  // Already loaded
+  if (sky_hrtime != 0) {
+    return Qnil;
+  }
+
+  res = sky_load_libskylight(StringValueCStr(path));
+
+  if (res < 0) {
+    rb_raise(rb_eRuntimeError, "[SKYLIGHT] dlerror; msg=%s", dlerror());
+    return Qnil;
+  }
+
+  return Qnil;
+}
+
+/*
+ *
+ * class Skylight::Util::Clock
+ *
+ */
+
+static VALUE
+clock_high_res_time(VALUE self) {
+  UNUSED(self);
+  return ULL2NUM(sky_hrtime());
+}
+
+/*
+ *
+ * class Skylight::Instrumenter
+ *
+ */
+
+static VALUE
+instrumenter_new(VALUE klass, VALUE rb_env) {
+  sky_instrumenter_t* instrumenter;
+  sky_buf_t env[256];
+  int i, envc;
+
+  UNUSED(klass);
+  CHECK_TYPE(rb_env, T_ARRAY);
+
+  if (RARRAY_LEN(rb_env) >= 256) {
+    rb_raise(rb_eArgError, "environment array too long");
+    return Qnil;
+  }
+
+  envc = (int) RARRAY_LEN(rb_env);
+
+  for (i = 0; i < envc; ++i) {
+    VALUE val = rb_ary_entry(rb_env, i);
+
+    // Make sure it is a string
+    CHECK_TYPE(val, T_STRING);
+
+    env[i] = STR2BUF(val);
+  }
+
+  CHECK_FFI(
+      sky_instrumenter_new(env, envc, &instrumenter),
+      "failed to initialize instrumenter");
+
+  return Data_Wrap_Struct(rb_cInstrumenter, NULL, sky_instrumenter_free, instrumenter);
+}
+
+static void*
+instrumenter_start_nogvl(sky_instrumenter_t* instrumenter) {
+  /*
+   * Cannot use CHECK_FFI in here
+   */
+
+  if (sky_instrumenter_start(instrumenter) == 0) {
+    sky_activate_memprof();
+
+    return (void*) Qtrue;
+  }
+  else {
+    return (void*) Qfalse;
+  }
+}
+
+static VALUE
+instrumenter_start(VALUE self) {
+  sky_instrumenter_t* instrumenter;
+
+  My_Struct(instrumenter, sky_instrumenter_t, no_instrumenter_msg);
+
+  return (VALUE) WITHOUT_GVL(instrumenter_start_nogvl, instrumenter);
+}
+
+static VALUE
+instrumenter_stop(VALUE self) {
+  sky_instrumenter_t* instrumenter;
+
+  My_Struct(instrumenter, sky_instrumenter_t, no_instrumenter_msg);
+
+  CHECK_FFI(
+      sky_instrumenter_stop(instrumenter),
+      "native Instrumenter#stop failed");
+
+  sky_deactivate_memprof();
+
+  return Qnil;
+}
+
+static VALUE
+instrumenter_submit_trace(VALUE self, VALUE rb_trace) {
+  sky_instrumenter_t* instrumenter;
+  sky_trace_t* trace;
+
+  My_Struct(instrumenter, sky_instrumenter_t, no_instrumenter_msg);
+  Transfer_Struct(trace, rb_trace, sky_trace_t, consumed_trace_msg);
+
+  CHECK_FFI(
+      sky_instrumenter_submit_trace(instrumenter, trace),
+      "native Instrumenter#submit_trace failed");
+
+  return Qnil;
+}
+
+/*
+ *
+ * class Skylight::Trace
+ *
+ */
+
+static VALUE
+trace_new(VALUE klass, VALUE start, VALUE uuid, VALUE endpoint) {
+  sky_trace_t* trace;
+
+  UNUSED(klass);
+  CHECK_NUMERIC(start);
+  CHECK_TYPE(uuid, T_STRING);
+  CHECK_TYPE(endpoint, T_STRING);
+
+  CHECK_FFI(
+      sky_trace_new(NUM2ULL(start), STR2BUF(uuid), STR2BUF(endpoint), &trace),
+      "native Trace#new failed");
+
+  sky_clear_allocation_count();
+
+  return Data_Wrap_Struct(rb_cTrace, NULL, sky_trace_free, trace);
+}
+
+static VALUE
+trace_get_started_at(VALUE self) {
+  uint64_t start;
+  sky_trace_t* trace;
+
+  My_Struct(trace, sky_trace_t, consumed_trace_msg);
+
+  CHECK_FFI(
+      sky_trace_start(trace, &start),
+      "native Trace#started_at failed");
+
+  return ULL2NUM(start);
+}
+
+static VALUE
+trace_get_endpoint(VALUE self) {
+  sky_trace_t* trace;
+  sky_buf_t endpoint;
+
+  My_Struct(trace, sky_trace_t, consumed_trace_msg);
+
+  CHECK_FFI(
+      sky_trace_endpoint(trace, &endpoint),
+      "native Trace#endpoint failed");
+
+  return BUF2STR(endpoint);
+}
+
+static VALUE
+trace_set_endpoint(VALUE self, VALUE endpoint) {
+  sky_trace_t* trace;
+
+  CHECK_TYPE(endpoint, T_STRING);
+  My_Struct(trace, sky_trace_t, consumed_trace_msg);
+
+  CHECK_FFI(
+      sky_trace_set_endpoint(trace, STR2BUF(endpoint)),
+      "native Trace#set_endpoint failed");
+
+  return Qnil;
+}
+
+static VALUE
+trace_get_uuid(VALUE self) {
+  sky_trace_t* trace;
+  sky_buf_t uuid;
+
+  My_Struct(trace, sky_trace_t, consumed_trace_msg);
+
+  CHECK_FFI(
+      sky_trace_uuid(trace, &uuid),
+      "native Trace#uuid failed");
+
+  return BUF2STR(uuid);
+}
+
+static VALUE
+trace_start_span(VALUE self, VALUE time, VALUE category) {
+  sky_trace_t* trace;
+  uint32_t span;
+
+  My_Struct(trace, sky_trace_t, consumed_trace_msg);
+
+  CHECK_NUMERIC(time);
+  CHECK_TYPE(category, T_STRING);
+
+  CHECK_FFI(
+      sky_trace_instrument(trace, NUM2ULL(time), STR2BUF(category), &span),
+      "native Trace#start_span failed");
+
+  if (sky_have_memprof()) {
+    sky_trace_span_add_uint_annotation(trace, span, 2, sky_consume_allocations());
+  }
+
+  return UINT2NUM(span);
+}
+
+static VALUE
+trace_stop_span(VALUE self, VALUE span, VALUE time) {
+  sky_trace_t* trace;
+
+  My_Struct(trace, sky_trace_t, consumed_trace_msg);
+
+  CHECK_NUMERIC(time);
+  CHECK_TYPE(span, T_FIXNUM);
+
+  if (sky_have_memprof()) {
+    sky_trace_span_add_uint_annotation(trace, FIX2UINT(span), 1, sky_consume_allocations());
+  }
+
+  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 span, VALUE title) {
+  sky_trace_t* trace;
+
+  My_Struct(trace, sky_trace_t, consumed_trace_msg);
+
+  CHECK_TYPE(span, T_FIXNUM);
+  CHECK_TYPE(title, T_STRING);
+
+  CHECK_FFI(
+      sky_trace_span_set_title(trace, FIX2UINT(span), STR2BUF(title)),
+      "native Trace#span_set_title failed");
+
+  return Qnil;
+}
+
+static VALUE
+trace_span_set_description(VALUE self, VALUE span, VALUE desc) {
+  sky_trace_t* trace;
+
+  My_Struct(trace, sky_trace_t, consumed_trace_msg);
+
+  CHECK_TYPE(span, T_FIXNUM);
+  CHECK_TYPE(desc, T_STRING);
+
+  CHECK_FFI(
+      sky_trace_span_set_desc(trace, FIX2UINT(span), STR2BUF(desc)),
+      "native Trace#span_set_description failed");
+
+  return Qnil;
+}
+
+void Init_skylight_native() {
+  rb_mSkylight = rb_define_module("Skylight");
+  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_cTrace = rb_define_class_under(rb_mSkylight, "Trace", rb_cObject);
+  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_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_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_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);
+}