ruby-static-tracing 0.0.13 → 0.0.14

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

@@ -4,8 +4,8 @@
 // Include libstapsdt.h to wrap
 #include <libstapsdt.h> // FIXME use local
 
-#include "types.h"
 #include "ruby_static_tracing.h"
+#include "types.h"
 
 typedef struct {
   char *name;
@@ -54,11 +54,23 @@ provider_disable(VALUE self);
 VALUE
 provider_destroy(VALUE self);
 
+/*
+ * call-seq:
+ *    provider.path() -> string
+ *
+ * Get a path to this provider, if the platform supports it
+ *
+ * Returns string for path, or empty string if failed
+ */
+VALUE
+provider_path(VALUE self);
+
 // Allocate a static_tracing_provider_type struct for ruby memory management
 VALUE
 static_tracing_provider_alloc(VALUE klass);
 
-SDTProbe_t
-*provider_add_tracepoint_internal(VALUE self, const char* name, int argc, Tracepoint_arg_types *args);
+SDTProbe_t *provider_add_tracepoint_internal(VALUE self, const char *name,
+                                             int argc,
+                                             Tracepoint_arg_types *args);
 
-#endif //STATIC_TRACING_PROVIDER_H
+#endif // STATIC_TRACING_PROVIDER_H

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

@@ -2,8 +2,7 @@
 
 VALUE eUSDT, eInternal;
 
-void Init_ruby_static_tracing()
-{
+void Init_ruby_static_tracing() {
   VALUE cStaticTracing, cProvider, cTracepoint;
 
   cStaticTracing = rb_const_get(rb_cObject, rb_intern("StaticTracing"));
@@ -15,7 +14,7 @@ void Init_ruby_static_tracing()
    */
   cProvider = rb_const_get(cStaticTracing, rb_intern("Provider"));
 
- /*
+  /*
    * Document-class: Statictracing::Tracepoint
    *
    *  A Tracepoint is a wrapper around an SDTProbe
@@ -36,13 +35,14 @@ void Init_ruby_static_tracing()
 
   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, "_enable_provider", provider_enable, 0);
+  rb_define_method(cProvider, "_disable_provider", provider_disable, 0);
   rb_define_method(cProvider, "destroy", provider_destroy, 0);
+  rb_define_method(cProvider, "path", provider_path, 0);
 
   rb_define_alloc_func(cTracepoint, static_tracing_tracepoint_alloc);
-  rb_define_method(cTracepoint, "tracepoint_initialize", tracepoint_initialize, 3);
+  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/linux/tracepoint.c

@@ -1,29 +1,23 @@
 #include "tracepoint.h"
 
-static const rb_data_type_t
-static_tracing_tracepoint_type;
+static const rb_data_type_t static_tracing_tracepoint_type;
 
-static const char*
-check_name_arg(VALUE provider);
+static const char *check_name_arg(VALUE provider);
 
-static const char*
-check_provider_arg(VALUE provider);
+static const char *check_provider_arg(VALUE provider);
 
-static Tracepoint_arg_types
-*check_vargs(int *argc, VALUE vargs);
+static Tracepoint_arg_types *check_vargs(int *argc, VALUE vargs);
 
-static Tracepoint_fire_arg
-*check_fire_args(int *argc, VALUE vargs);
+static Tracepoint_fire_arg *check_fire_args(int *argc, VALUE vargs);
 
 VALUE
-tracepoint_initialize(VALUE self, VALUE provider, VALUE name, VALUE vargs)
-{
+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);
+  c_name_str = check_name_arg(name);
   check_provider_arg(provider); // FIXME should only accept string
   Tracepoint_arg_types *args = check_vargs(&argc, vargs);
 
@@ -33,8 +27,10 @@ tracepoint_initialize(VALUE self, VALUE provider, VALUE name, VALUE vargs)
   cProviderInst = rb_funcall(cProvider, rb_intern("register"), 1, provider);
 
   // Use the provider to register a tracepoint
-  SDTProbe_t *probe = provider_add_tracepoint_internal(cProviderInst, c_name_str, argc, args);
-  TypedData_Get_Struct(self, static_tracing_tracepoint_t, &static_tracing_tracepoint_type, tracepoint);
+  SDTProbe_t *probe =
+      provider_add_tracepoint_internal(cProviderInst, c_name_str, argc, args);
+  TypedData_Get_Struct(self, static_tracing_tracepoint_t,
+                       &static_tracing_tracepoint_type, tracepoint);
 
   // Stare the tracepoint handle in our struct
   tracepoint->sdt_tracepoint = probe;
@@ -44,39 +40,53 @@ tracepoint_initialize(VALUE self, VALUE provider, VALUE name, VALUE vargs)
 }
 
 VALUE
-tracepoint_fire(VALUE self, VALUE vargs)
-{
+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);
+  TypedData_Get_Struct(self, static_tracing_tracepoint_t,
+                       &static_tracing_tracepoint_type, res);
   int argc = 0;
 
   Tracepoint_fire_arg *args = check_fire_args(&argc, vargs);
-  switch(argc)
-  {
-    case 0: probeFire(res->sdt_tracepoint); break;
-    case 1: probeFire(res->sdt_tracepoint, args[0]); break;
-    case 2: probeFire(res->sdt_tracepoint, args[0], args[1]); break;
-    case 3: probeFire(res->sdt_tracepoint, args[0], args[1], args[2]); break;
-    case 4: probeFire(res->sdt_tracepoint, args[0], args[1], args[2], args[3]); break;
-    case 5: probeFire(res->sdt_tracepoint, args[0], args[1], args[2], args[3], args[4]); break;
-    case 6: probeFire(res->sdt_tracepoint, args[0], args[1], args[2], args[3], args[4], args[5]); break;
-    default: probeFire(res->sdt_tracepoint); break;
+  switch (argc) {
+  case 0:
+    probeFire(res->sdt_tracepoint);
+    break;
+  case 1:
+    probeFire(res->sdt_tracepoint, args[0]);
+    break;
+  case 2:
+    probeFire(res->sdt_tracepoint, args[0], args[1]);
+    break;
+  case 3:
+    probeFire(res->sdt_tracepoint, args[0], args[1], args[2]);
+    break;
+  case 4:
+    probeFire(res->sdt_tracepoint, args[0], args[1], args[2], args[3]);
+    break;
+  case 5:
+    probeFire(res->sdt_tracepoint, args[0], args[1], args[2], args[3], args[4]);
+    break;
+  case 6:
+    probeFire(res->sdt_tracepoint, args[0], args[1], args[2], args[3], args[4],
+              args[5]);
+    break;
+  default:
+    probeFire(res->sdt_tracepoint);
+    break;
   }
 
   return Qnil;
 }
 
 VALUE
-tracepoint_enabled(VALUE self)
-{
+tracepoint_enabled(VALUE self) {
   static_tracing_tracepoint_t *res = NULL;
-  TypedData_Get_Struct(self, static_tracing_tracepoint_t, &static_tracing_tracepoint_type, res);
+  TypedData_Get_Struct(self, static_tracing_tracepoint_t,
+                       &static_tracing_tracepoint_type, res);
   return probeIsEnabled(res->sdt_tracepoint) == 1 ? Qtrue : Qfalse;
 }
 
-static const char*
-check_name_arg(VALUE name)
-{
+static const char *check_name_arg(VALUE name) {
   const char *c_name_str = NULL;
 
   if (TYPE(name) != T_SYMBOL && TYPE(name) != T_STRING) {
@@ -91,9 +101,7 @@ check_name_arg(VALUE name)
   return c_name_str;
 }
 
-static const char*
-check_provider_arg(VALUE provider)
-{
+static const char *check_provider_arg(VALUE provider) {
   const char *c_provider_str = NULL;
 
   if (TYPE(provider) != T_SYMBOL && TYPE(provider) != T_STRING) {
@@ -108,25 +116,22 @@ check_provider_arg(VALUE provider)
   return c_provider_str;
 }
 
-static Tracepoint_arg_types
-*check_vargs(int *argc, VALUE vargs)
-{
-  if(TYPE(vargs) == T_ARRAY)
-  {
+static Tracepoint_arg_types *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);
+    if (*argc > 6) {
+      printf("ERROR - passed %i args, maximum 6 argument types can be passed",
+             *argc);
       return NULL;
     }
     int i;
     Tracepoint_arg_types *args = malloc(*argc * sizeof(Tracepoint_arg_types));
-    for (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);
+    for (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] = Integer;
       } else if (strcmp(cStr, "String")) {
@@ -142,37 +147,32 @@ static Tracepoint_arg_types
   }
 }
 
-static Tracepoint_fire_arg
-*check_fire_args(int *argc, VALUE vargs)
-{
-  if(TYPE(vargs) == T_ARRAY)
-  {
+static Tracepoint_fire_arg *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);
+    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);
+    // printf("SIZE: %i ARGC: %i \n", sizeof(Tracepoint_fire_arg), *argc);
     int i;
-    for (i = 0; i < *argc; i++)
-    {
+    for (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;
+      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;
       }
     }
     return args;
@@ -184,43 +184,33 @@ static Tracepoint_fire_arg
 
 // Allocate a static_tracing_tracepoint_type struct for ruby memory management
 VALUE
-static_tracing_tracepoint_alloc(VALUE klass)
-{
+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);
+  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_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) {
+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)
-{
+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
-};
+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};

data/ext/ruby-static-tracing/linux/tracepoint.h

@@ -10,7 +10,7 @@
 
 typedef union {
   unsigned long long intval;
-  char *             strval;
+  char *strval;
 } Tracepoint_fire_arg;
 
 typedef struct {
@@ -50,4 +50,4 @@ tracepoint_enabled(VALUE self);
 VALUE
 static_tracing_tracepoint_alloc(VALUE klass);
 
-#endif //STATIC_TRACING_TRACEPOINT_H
+#endif // STATIC_TRACING_TRACEPOINT_H

data/ext/ruby-static-tracing/linux/types.h

@@ -4,8 +4,8 @@
 #include <libstapsdt.h>
 
 typedef enum TRACEPOINT_ARG_TYPES_ENUM {
-  Integer = int64,  // STAP enum type -8
-  String  = uint64, // STAP enum type 8
+  Integer = int64, // STAP enum type -8
+  String = uint64, // STAP enum type 8
 } Tracepoint_arg_types;
 
 #endif // STATIC_TRACING_TYPEs_H

data/lib/ruby-static-tracing.rb

@@ -11,7 +11,7 @@ require 'ruby-static-tracing/configuration'
 require 'ruby-static-tracing/tracer'
 require 'ruby-static-tracing/tracers'
 
-# FIXME Including StaticTracing should cause every method in a module or class to be registered
+# FIXME: Including StaticTracing should cause every method in a module or class to be registered
 # Implement this by introspecting all methods on the includor, and wrapping them.
 module StaticTracing
   extend self
@@ -24,8 +24,10 @@ module StaticTracing
 
   self.logger = Logger.new(STDERR)
 
+  # This will print a message indicating that tracepoints are disabled on this platform
   def issue_disabled_tracepoints_warning
     return if defined?(@warning_issued)
+
     @warning_issued = true
     logger.info("USDT tracepoints are not presently supported supported on #{RUBY_PLATFORM} - all operations will no-op")
   end
@@ -47,7 +49,7 @@ module StaticTracing
   # with a wrapped version that has tracing enabled
   def enable!
     StaticTracing::Tracers.enable!
-    StaticTracing::Provider.enable!
+    StaticTracing::Provider.enable! # FIXME individually call enable
     @enabled = true
   end
 
@@ -55,14 +57,20 @@ module StaticTracing
   # no longer wrapping them
   def disable!
     StaticTracing::Tracers.disable!
-    StaticTracing::Provider.disable!
+    StaticTracing::Provider.disable! # FIXME dangerous
     @enabled = false
   end
 
+  # Toggles between enabling and disabling tracepoints declared through tracers
   def toggle_tracing!
     enabled? ? disable! : enable!
   end
 
+  # Block to configure static tracing, eg:
+  #
+  #   StaticTracing.configure do |config|
+  #     config.add_tracer(StaticTracing::Tracer::Latency)
+  #   end
   def configure
     yield Configuration.instance
   end

data/lib/ruby-static-tracing/configuration.rb

@@ -2,6 +2,7 @@
 
 module StaticTracing
   class Configuration
+    # Modes of operation for tracers
     module Modes
       ON = 'ON'
       OFF = 'OFF'
@@ -20,34 +21,42 @@ module StaticTracing
 
     attr_reader :mode, :signal
 
+    # A new configuration instance
     def initialize
       @mode = Modes::SIGNAL
       @signal = Modes::SIGNALS::SIGPROF
       enable_trap
     end
 
+    # Sets the mode [ON, OFF, SIGNAL]
+    # Default is SIGNAL
     def mode=(new_mode)
       handle_old_mode
       @mode = new_mode
       handle_new_mode
     end
 
+    # Sets the SIGNAL to listen to,
+    # Default is SIGPROF
     def signal=(new_signal)
       disable_trap
       @signal = new_signal
       enable_trap
     end
 
+    # Adds a new tracer globally
     def add_tracer(tracer)
       Tracers.add(tracer)
     end
 
     private
 
+    # Clean up trap handlers if mode changed to not need it
     def handle_old_mode
       disable_trap if @mode == Modes::SIGNAL
     end
 
+    # Enable trap handlers if needed
     def handle_new_mode
       if @mode == Modes::SIGNAL
         enable_trap
@@ -58,10 +67,12 @@ module StaticTracing
       end
     end
 
+    # Disables trap handler
     def disable_trap
       Signal.trap(@signal, 'DEFAULT')
     end
 
+    # Enables a new trap handler
     def enable_trap
       Signal.trap(@signal) { StaticTracing.toggle_tracing! }
     end