ruby-static-tracing 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 394cdc6b04834088de888916e5ebcfb9481a8c75
-  data.tar.gz: 744d75e5564b7e3e0021d64cf2e141b97090e999
+SHA256:
+  metadata.gz: f901c3dd17e5873073d011db778b9ef22983fa9c6225be6b90abc226e223d1ff
+  data.tar.gz: 525513e06cc54471b1f2c09f3c8d82e4ba47fac56b89e3d68a80ac8747dd4d3f
 SHA512:
-  metadata.gz: e23b757367de4ddb676dbaac7da56d0d4ccb70e0bc7d4762df30c66221d0c5ec9cd2a2e2cc448c11c3bc11607d2e52b76d9eae451ed40a49883abf4cc478f2ff
-  data.tar.gz: 8ab4b39ffc8e234d9570bfc3cc1b62a019c3cbe7b1a4bcb595a7d09e01e9acd5280d9e5b97d6c597d9bab85970395f85d1183a50b0290e61d59e5d29d13132ca
+  metadata.gz: 987a3b0391cdbf22db11795cf5d53f5ebe8d71bf9962969a73fbf952dd455ff4656c3b4ca88dc01d8418b4278f84f83a10b8943be7aaf0da1a0329b861aa2015
+  data.tar.gz: f14b0d94b0bfce0ea110a379cb1954a51c498fd5b4370ecc7bbee5fecf40c11a66bf725a28a79e690a1a7119f3d5d31ac9691e2c83ecaa17391003383328c3e9

data/ext/ruby-static-tracing/darwin/provider.c

@@ -0,0 +1,128 @@
+#include "provider.h"
+
+static const rb_data_type_t
+static_tracing_provider_type;
+
+// Forward decls
+static const char*
+check_name_arg(VALUE name);
+
+/*
+  Wraps usdt_create_provider from libusdt.h
+*/
+VALUE
+provider_initialize(VALUE self, VALUE name)
+{
+  const char *c_name_str = NULL;
+  static_tracing_provider_t *res = NULL;
+
+  c_name_str = check_name_arg(name);
+
+  TypedData_Get_Struct(self, static_tracing_provider_t, &static_tracing_provider_type, res);
+  res->usdt_provider = usdt_create_provider(c_name_str, c_name_str); // FIXME make module from name and just prepend "_module_"
+  return self;
+}
+
+// // Internal function used to register a tracepoint against a provider instance
+int
+provider_add_tracepoint_internal(VALUE self, usdt_probedef_t *probedef)
+{
+  static_tracing_provider_t *res = NULL;
+  TypedData_Get_Struct(self, static_tracing_provider_t, &static_tracing_provider_type, res);
+  return usdt_provider_add_probe(res->usdt_provider, probedef) == 0 ? Qtrue : Qfalse;
+}
+
+/*
+  Wraps usdt_provider_enable from libusdt.h
+*/
+VALUE
+provider_enable(VALUE self)
+{
+  static_tracing_provider_t *res = NULL;
+  TypedData_Get_Struct(self, static_tracing_provider_t, &static_tracing_provider_type, res);
+  return usdt_provider_enable(res->usdt_provider) == 0 ? Qtrue : Qfalse;
+}
+
+/*
+ Wraps usdt_provider_disable from libusdt.h
+*/
+VALUE
+provider_disable(VALUE self)
+{
+  static_tracing_provider_t *res = NULL;
+  TypedData_Get_Struct(self, static_tracing_provider_t, &static_tracing_provider_type, res);
+  return usdt_provider_disable(res->usdt_provider) == 0 ? Qtrue : Qfalse;
+}
+
+/*
+ Wraps usdt_provider_free from libusdt.h
+*/
+VALUE
+provider_destroy(VALUE self)
+{
+  static_tracing_provider_t *res = NULL;
+  TypedData_Get_Struct(self, static_tracing_provider_t, &static_tracing_provider_type, res);
+  usdt_provider_free(res->usdt_provider);
+  return Qnil;
+}
+
+// Allocate a static_tracing_provider_type struct for ruby memory management
+VALUE
+static_tracing_provider_alloc(VALUE klass)
+{
+  static_tracing_provider_t *res;
+  VALUE obj = TypedData_Make_Struct(klass, static_tracing_provider_t, &static_tracing_provider_type, res);
+  return obj;
+}
+
+
+static const char*
+check_name_arg(VALUE name)
+{
+  const char *c_name_str = NULL;
+
+  if (TYPE(name) != T_SYMBOL && TYPE(name) != T_STRING) {
+    rb_raise(rb_eTypeError, "name must be a symbol or string");
+  }
+  if (TYPE(name) == T_SYMBOL) {
+    c_name_str = rb_id2name(rb_to_id(name));
+  } else if (TYPE(name) == T_STRING) {
+    c_name_str = RSTRING_PTR(name);
+  }
+
+  return c_name_str;
+}
+
+static inline void
+static_tracing_provider_mark(void *ptr)
+{
+  /* noop */
+}
+
+static inline void
+static_tracing_provider_free(void *ptr)
+{
+  static_tracing_provider_t *res = (static_tracing_provider_t *) ptr;
+  //if (res->name) {
+  //  free(res->name);
+  //  res->name = NULL;
+  //}
+  xfree(res);
+}
+
+static inline size_t
+static_tracing_provider_memsize(const void *ptr)
+{
+  return sizeof(static_tracing_provider_t);
+}
+
+static const rb_data_type_t
+static_tracing_provider_type = {
+  "static_tracing_provider",
+  {
+    static_tracing_provider_mark,
+    static_tracing_provider_free,
+    static_tracing_provider_memsize
+  },
+  NULL, NULL, RUBY_TYPED_FREE_IMMEDIATELY
+};

data/ext/ruby-static-tracing/darwin/provider.h

@@ -0,0 +1,62 @@
+#ifndef STATIC_TRACING_PROVIDER_H
+#define STATIC_TRACING_PROVIDER_H
+
+#include "usdt.h"
+
+#include "ruby_static_tracing.h"
+#include "tracepoint.h"
+
+typedef struct {
+  char *name;
+  usdt_provider_t *usdt_provider;
+} static_tracing_provider_t;
+
+/*
+ * call-seq:
+ *    StaticTracing::Provider.new(id) -> provider
+ *
+ * Creates a new Provider.
+ */
+VALUE
+provider_initialize(VALUE self, VALUE id);
+
+/*
+ * call-seq:
+ *    provider.enable() -> true
+ *
+ * Enable this provider
+ *
+ * Return true if the enable operation succeeded
+ */
+VALUE
+provider_enable(VALUE self);
+
+/*
+ * call-seq:
+ *    provider.disable() -> true
+ *
+ * Disable this provider
+ *
+ * Return true if the disable operation succeeded
+ */
+VALUE
+provider_disable(VALUE self);
+/*
+ * call-seq:
+ *    provider.destroy() -> true
+ *
+ * Destroys this provider.
+ *
+ * Return true if the destory operation succeeded
+ */
+VALUE
+provider_destroy(VALUE self);
+
+// Allocate a static_tracing_provider_type struct for ruby memory management
+VALUE
+static_tracing_provider_alloc(VALUE klass);
+
+int
+provider_add_tracepoint_internal(VALUE self, usdt_probedef_t* probedef);
+
+#endif //STATIC_TRACING_PROVIDER_H

data/ext/ruby-static-tracing/darwin/ruby_static_tracing.c

@@ -0,0 +1,48 @@
+#include "ruby_static_tracing.h"
+
+VALUE eUSDT, eInternal;
+
+void Init_ruby_static_tracing()
+{
+  VALUE cStaticTracing, cProvider, cTracepoint;
+
+  cStaticTracing = rb_const_get(rb_cObject, rb_intern("StaticTracing"));
+
+  /*
+   * Document-class: StaticTracing::Provider
+   *
+   *  Provider is the wrapper around libstapsdt
+   */
+  cProvider = rb_const_get(cStaticTracing, rb_intern("Provider"));
+
+ /*
+   * Document-class: Statictracing::Tracepoint
+   *
+   *  A Tracepoint is a wrapper around an SDTProbe
+   */
+  cTracepoint = rb_const_get(cStaticTracing, rb_intern("Tracepoint"));
+
+  /* Document-class: StaticTracing::SyscallError
+   *
+   * Represents failures to fire a tracepoint or register a provider
+   */
+  eUSDT = rb_const_get(cStaticTracing, rb_intern("USDTError"));
+
+  /* Document-class: StaticTracing::InternalError
+   *
+   * An internal StaticTracing error. These errors may constitute bugs.
+   */
+  eInternal = rb_const_get(cStaticTracing, rb_intern("InternalError"));
+
+  rb_define_alloc_func(cProvider, static_tracing_provider_alloc);
+  rb_define_method(cProvider, "provider_initialize", provider_initialize, 1);
+  rb_define_method(cProvider, "enable", provider_enable, 0);
+  rb_define_method(cProvider, "disable", provider_disable, 0);
+  rb_define_method(cProvider, "destroy", provider_destroy, 0);
+
+  rb_define_alloc_func(cTracepoint, static_tracing_tracepoint_alloc);
+  rb_define_method(cTracepoint, "tracepoint_initialize", tracepoint_initialize, 3);
+  rb_define_method(cTracepoint, "_fire_tracepoint", tracepoint_fire, 1);
+  rb_define_method(cTracepoint, "enabled?", tracepoint_enabled, 0);
+}
+

data/ext/ruby-static-tracing/darwin/tracepoint.c

@@ -0,0 +1,231 @@
+#include "tracepoint.h"
+
+static const rb_data_type_t
+static_tracing_tracepoint_type;
+
+static const char*
+check_name_arg(VALUE provider);
+
+static const char*
+check_provider_arg(VALUE provider);
+
+static char
+**check_vargs(int *argc, VALUE vargs);
+
+static void
+**check_fire_args(int *argc, VALUE vargs);
+
+VALUE
+tracepoint_initialize(VALUE self, VALUE provider, VALUE name, VALUE vargs)
+{
+  VALUE cStaticTracing, cProvider, cProviderInst;
+  static_tracing_tracepoint_t *tracepoint = NULL;
+  const char *c_name_str = NULL;
+  int argc = 0;
+
+  c_name_str     = check_name_arg(name);
+  check_provider_arg(provider); // FIXME should only accept string
+  char **args = check_vargs(&argc, vargs);
+
+  /// Get a handle to global provider list for lookup
+  cStaticTracing = rb_const_get(rb_cObject, rb_intern("StaticTracing"));
+  cProvider = rb_const_get(cStaticTracing, rb_intern("Provider"));
+  cProviderInst = rb_funcall(cProvider, rb_intern("register"), 1, provider);
+
+  // Create a probe
+  usdt_probedef_t *probe = usdt_create_probe(c_name_str, c_name_str, argc, args);
+
+  // Use the provider to register a tracepoint
+  int success = provider_add_tracepoint_internal(cProviderInst, probe); // FIXME handle error checking here and throw an exception if failure
+  TypedData_Get_Struct(self, static_tracing_tracepoint_t, &static_tracing_tracepoint_type, tracepoint);
+
+  // FIXME check for nulls
+  // FIXME Do we really need to store both references? refactor this.
+  // Store the tracepoint handle in our struct
+  tracepoint->usdt_tracepoint_def = probe;
+
+  return self;
+}
+
+VALUE
+tracepoint_fire(VALUE self, VALUE vargs)
+{
+  static_tracing_tracepoint_t *res = NULL;
+  TypedData_Get_Struct(self, static_tracing_tracepoint_t, &static_tracing_tracepoint_type, res);
+  int argc = 0;
+  void *args = check_fire_args(&argc, vargs);
+
+  usdt_fire_probe(res->usdt_tracepoint_def->probe, argc, args);
+  return Qnil;
+}
+
+VALUE
+tracepoint_enabled(VALUE self)
+{
+  static_tracing_tracepoint_t *res = NULL;
+  TypedData_Get_Struct(self, static_tracing_tracepoint_t, &static_tracing_tracepoint_type, res);
+  return usdt_is_enabled(res->usdt_tracepoint_def->probe) == 0 ? Qfalse : Qtrue;
+}
+
+static const char*
+check_name_arg(VALUE name)
+{
+  const char *c_name_str = NULL;
+
+  if (TYPE(name) != T_SYMBOL && TYPE(name) != T_STRING) {
+    rb_raise(rb_eTypeError, "name must be a symbol or string");
+  }
+  if (TYPE(name) == T_SYMBOL) {
+    c_name_str = rb_id2name(rb_to_id(name));
+  } else if (TYPE(name) == T_STRING) {
+    c_name_str = RSTRING_PTR(name);
+  }
+
+  return c_name_str;
+}
+
+static const char*
+check_provider_arg(VALUE provider)
+{
+  const char *c_provider_str = NULL;
+
+  if (TYPE(provider) != T_SYMBOL && TYPE(provider) != T_STRING) {
+    rb_raise(rb_eTypeError, "provider must be a symbol or string");
+  }
+  if (TYPE(provider) == T_SYMBOL) {
+    c_provider_str = rb_id2name(rb_to_id(provider));
+  } else if (TYPE(provider) == T_STRING) {
+    c_provider_str = RSTRING_PTR(provider);
+  }
+
+  return c_provider_str;
+}
+
+static char
+**check_vargs(int *argc, VALUE vargs)
+{
+  if(TYPE(vargs) == T_ARRAY)
+  {
+    VALUE rLength = rb_funcall(vargs, rb_intern("length"), 0, Qnil);
+    *argc = NUM2INT(rLength);
+
+    if(*argc > 6)
+    {
+      printf("ERROR - passed %i args, maximum 6 argument types can be passed", *argc);
+      return NULL;
+    }
+    // FIXME ensure this is freed
+    char **args = malloc(*argc * sizeof(char*));
+    for (int i = 0; i < *argc; i++)
+    {
+      VALUE str = rb_funcall(rb_ary_entry(vargs, i), rb_intern("to_s"), 0, Qnil);
+      const char* cStr = RSTRING_PTR(str);
+      if (strcmp(cStr, "Integer")) {
+        args[i] = strdup(cStr);
+      } else if (strcmp(cStr, "String")) {
+        args[i] = strdup(cStr);
+      } else {
+        printf("ERROR - type \"%s\" is unsupported\n", cStr);
+      }
+    }
+    return args;
+  } else {
+    printf("ERROR - array was expected\n");
+    return NULL;
+  }
+}
+
+
+/*
+ * Yeah, returning a void ** array is a bit sketchy, but since
+ * usdt_fire_probe takes a void **, that's what we'll give it.
+ *
+ * The structure of the data is actually an array of 64 bit unions
+ * So the size of the data should be argc * 8 bytes.
+ * We assume that reads will be aligned on 64 bits in the tracer.
+ *
+ * The approach libstapsdt takes is pretty similar, just not an array.
+*/
+static void
+**check_fire_args(int *argc, VALUE vargs)
+{
+  if(TYPE(vargs) == T_ARRAY)
+  {
+    VALUE rLength = rb_funcall(vargs, rb_intern("length"), 0, Qnil);
+    *argc = NUM2INT(rLength);
+
+    if(*argc > 6)
+    {
+      printf("ERROR - passed %i args, maximum 6 argument types can be passed", *argc);
+      return NULL;
+    }
+
+    Tracepoint_fire_arg *args = malloc(*argc * sizeof(Tracepoint_fire_arg));
+    //printf("SIZE: %i ARGC: %i \n", sizeof(Tracepoint_fire_arg), *argc);
+    // FIXME check against registered argtypes here
+    for (int i = 0; i < *argc; i++)
+    {
+      VALUE val = rb_ary_entry(vargs, i);
+      switch(TYPE(val))
+      {
+        case T_FIXNUM:
+          args[i].intval = FIX2LONG(val);
+          break;
+        case T_STRING:
+          args[i].strval = RSTRING_PTR(val);
+          break;
+        default:
+          printf("ERROR unsupported type passed for argument %i to fire\n", i);
+          break;
+      }
+    }
+    // This downcast is explained the comment section of this function.
+    return (void **) args;
+  } else {
+    printf("ERROR - array was expected\n");
+    return NULL;
+  }
+}
+
+// Allocate a static_tracing_tracepoint_type struct for ruby memory management
+VALUE
+static_tracing_tracepoint_alloc(VALUE klass)
+{
+  static_tracing_tracepoint_t *res;
+  VALUE obj = TypedData_Make_Struct(klass, static_tracing_tracepoint_t, &static_tracing_tracepoint_type, res);
+  return obj;
+}
+
+static inline void
+static_tracing_tracepoint_mark(void *ptr)
+{
+  /* noop */
+}
+
+static inline void
+static_tracing_tracepoint_free(void *ptr)
+{
+  static_tracing_tracepoint_t *res = (static_tracing_tracepoint_t *) ptr;
+  //if (res->name) {
+  //  free(res->name);
+  //  res->name = NULL;
+  //}
+  xfree(res);
+}
+
+static inline size_t
+static_tracing_tracepoint_memsize(const void *ptr)
+{
+  return sizeof(static_tracing_provider_t);
+}
+
+static const rb_data_type_t
+static_tracing_tracepoint_type = {
+  "static_tracing_tracepoint",
+  {
+    static_tracing_tracepoint_mark,
+    static_tracing_tracepoint_free,
+    static_tracing_tracepoint_memsize
+  },
+  NULL, NULL, RUBY_TYPED_FREE_IMMEDIATELY
+};