ruby-static-tracing 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA256:
-  metadata.gz: 77e9c7647715d271d4cfdf9cb78359842ef0bae3f3582ea3f0248f3cbea2d288
-  data.tar.gz: bac4e1fb75dbbcea6304c1a1ee9e8597c31334dd56ff3b75eb3df32e173e130e
+SHA1:
+  metadata.gz: 394cdc6b04834088de888916e5ebcfb9481a8c75
+  data.tar.gz: 744d75e5564b7e3e0021d64cf2e141b97090e999
 SHA512:
-  metadata.gz: 482ef944a73814773fce74d5f4906ee7ab626c35b5838ec3ed26579706e544ccf0c86dd2cd45ad880e5b3d9e9f69c3d60785eb173f005eb700110ab16796cf8c
-  data.tar.gz: 9e311329c44e0081533e62b32eb78a4b1ef08671d60b37ceeee44cc565aedb270b3e3310ff21edaa756182ff36baea878428045668501d85bebbc1e373d4fff3
+  metadata.gz: e23b757367de4ddb676dbaac7da56d0d4ccb70e0bc7d4762df30c66221d0c5ec9cd2a2e2cc448c11c3bc11607d2e52b76d9eae451ed40a49883abf4cc478f2ff
+  data.tar.gz: 8ab4b39ffc8e234d9570bfc3cc1b62a019c3cbe7b1a4bcb595a7d09e01e9acd5280d9e5b97d6c597d9bab85970395f85d1183a50b0290e61d59e5d29d13132ca

data/ext/ruby-static-tracing/extconf.rb

@@ -3,25 +3,26 @@ $LOAD_PATH.unshift File.expand_path("../../../lib", __FILE__)
 require 'mkmf'
 require 'ruby-static-tracing/platform'
 
-unless StaticTracing.linux?
-end
-
 def platform_dir(platform)
   File.expand_path("../../../ext/ruby-static-tracing/#{platform}/", __FILE__)
 end
 
-if StaticTracing.linux?
+if StaticTracing::Platform.linux?
   abort 'libstapsdt.h is missing, please install libstapsdt' unless find_header('libstapsdt.h')
-  
+
   have_header 'libstapsdt.h'
-  
-  $CFLAGS = "-D_GNU_SOURCE -Werror -Wall "
+
+  unless have_library('stapsdt')
+    abort "libstapsdt is missing, please install it"
+  end
+
+  $CFLAGS = "-D_GNU_SOURCE -Wall " # -Werror  complaining
   if ENV.key?('DEBUG')
     $CFLAGS << "-O0 -g -DDEBUG"
   else
     $CFLAGS << "-O3"
   end
-  
+
   create_makefile('ruby-static-tracing/ruby_static_tracing', platform_dir("linux"))
 else
   # FIXME properly stub this.

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

@@ -0,0 +1,145 @@
+#include "provider.h"
+
+static const rb_data_type_t
+static_tracing_provider_type;
+
+// Forward decls
+static const char*
+check_name_arg(VALUE name);
+
+/*
+  Wraps ProviderInit from libstapsdt
+*/
+VALUE
+provider_initialize(VALUE self, VALUE name)
+{
+  const char *c_name_str = NULL;
+  static_tracing_provider_t *res = NULL;
+
+  // Check and cast arguments
+  c_name_str = check_name_arg(name);
+
+  // Build semian resource structure
+  TypedData_Get_Struct(self, static_tracing_provider_t, &static_tracing_provider_type, res);
+  res->sdt_provider = providerInit(c_name_str);
+  return self;
+}
+
+// Internal function used to register a tracepoint against a provider instance
+SDTProbe_t
+*provider_add_tracepoint_internal(VALUE self, const char* name, int argc, Tracepoint_arg_types *args)
+{
+  static_tracing_provider_t *res = NULL;
+  SDTProbe_t *probe;
+
+  TypedData_Get_Struct(self, static_tracing_provider_t, &static_tracing_provider_type, res);
+
+  switch(argc)
+  {
+    case 0: probe = providerAddProbe(res->sdt_provider, name, 0); break;
+    case 1: probe = providerAddProbe(res->sdt_provider, name, argc, args[0]); break;
+    case 2: probe = providerAddProbe(res->sdt_provider, name, argc, args[0], args[1]); break;
+    case 3: probe = providerAddProbe(res->sdt_provider, name, argc, args[0], args[1], args[2]); break;
+    case 4: probe = providerAddProbe(res->sdt_provider, name, argc, args[0], args[1], args[2], args[3]); break;
+    case 5: probe = providerAddProbe(res->sdt_provider, name, argc, args[0], args[1], args[2], args[3], args[4]); break;
+    case 6: probe = providerAddProbe(res->sdt_provider, name, argc, args[0], args[1], args[2], args[3], args[4], args[5]); break;
+    default: probe = providerAddProbe(res->sdt_provider, name, 0); break;
+  }
+
+  return probe;
+}
+
+/*
+  Wraps providerLoad from libstapsdt
+*/
+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 providerLoad(res->sdt_provider) == 0 ? Qtrue : Qfalse;
+}
+
+/*
+  Wraps providerUnload from libstapsdt
+*/
+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 providerUnload(res->sdt_provider) == 0 ? Qtrue : Qfalse;
+}
+
+/*
+  Wraps providerUnload from libstapsdt
+*/
+VALUE
+provider_destroy(VALUE self)
+{
+  static_tracing_provider_t *res = NULL;
+  TypedData_Get_Struct(self, static_tracing_provider_t, &static_tracing_provider_type, res);
+  providerDestroy(res->sdt_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/linux/provider.h

@@ -0,0 +1,69 @@
+/*
+For core static tracing functions exposed directly to ruby.
+Functions here are associated with rubyland operations.
+*/
+#ifndef STATIC_TRACING_PROVIDER_H
+#define STATIC_TRACING_PROVIDER_H
+
+#include <ruby.h>
+// Include libstapsdt.h to wrap
+#include <libstapsdt.h>
+
+#include "ruby_static_tracing.h"
+#include "tracepoint.h"
+
+typedef struct {
+  char *name;
+  SDTProvider_t *sdt_provider;
+  VALUE tracepoints;
+} 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);
+
+SDTProbe_t
+*provider_add_tracepoint_internal(VALUE self, const char* name, int argc, Tracepoint_arg_types *args);
+
+#endif //STATIC_TRACING_PROVIDER_H

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

@@ -1,4 +1,47 @@
+#include "provider.h"
+#include "tracepoint.h"
+
 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/linux/ruby_static_tracing.h

@@ -0,0 +1,19 @@
+/*
+System, 3rd party, and project includes
+Implements Init_ruby_static_tracing, which is used as C/Ruby entrypoint.
+*/
+
+#ifndef RUBY_STATIC_TRACING_H
+#define RUBY_STATIC_TRACING_H
+
+typedef enum TRACEPOINT_ARG_TYPES_ENUM {
+  Integer = int64,  // STAP enum type -8
+  String  = uint64, // STAP enum type 8
+} Tracepoint_arg_types;
+
+#include "provider.h"
+
+void Init_ruby_static_tracing();
+VALUE eUSDT, eInternal;
+
+#endif //RUBY_STATIC_TRACING_H

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

@@ -0,0 +1,226 @@
+#include "tracepoint.h"
+#include "provider.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 Tracepoint_arg_types
+*check_vargs(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)
+{
+  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
+  Tracepoint_arg_types *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);
+
+  // 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);
+
+  // Stare the tracepoint handle in our struct
+  tracepoint->sdt_tracepoint = probe;
+  tracepoint->args = args;
+
+  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;
+
+  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;
+  }
+
+  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 probeIsEnabled(res->sdt_tracepoint) == 1 ? Qtrue : Qfalse;
+}
+
+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 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);
+      return NULL;
+    }
+
+    Tracepoint_arg_types *args = malloc(*argc * sizeof(Tracepoint_arg_types));
+    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] = Integer;
+      } else if (strcmp(cStr, "String")) {
+        args[i] = String;
+      } else {
+        printf("ERROR - type \"%s\" is unsupported\n", cStr);
+      }
+    }
+    return args;
+  } else {
+    printf("ERROR - array was expected\n");
+    return NULL;
+  }
+}
+
+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);
+      return NULL;
+    }
+
+    Tracepoint_fire_arg *args = malloc(*argc * sizeof(Tracepoint_fire_arg));
+    //printf("SIZE: %i ARGC: %i \n", sizeof(Tracepoint_fire_arg), *argc);
+    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;
+      }
+    }
+    return 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
+};

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

@@ -0,0 +1,57 @@
+/*
+For core static tracing functions exposed directly to ruby.
+Functions here are associated with rubyland operations.
+*/
+#ifndef STATIC_TRACING_TRACEPOINT_H
+#define STATIC_TRACING_TRACEPOINT_H
+
+#include <ruby.h>
+// Include libstapsdt.h to wrap
+#include <libstapsdt.h>
+// Probably need to include provider.h to be able to initialize self
+
+#include "ruby_static_tracing.h"
+
+typedef union {
+  unsigned long long intval;
+  char *             strval;
+} Tracepoint_fire_arg;
+
+typedef struct {
+  char *name;
+  SDTProbe_t *sdt_tracepoint;
+  Tracepoint_arg_types *args;
+} static_tracing_tracepoint_t;
+
+/*
+ * call-seq:
+ *    StaticTracing::Tracepoint.new(provider, id, *vargs) -> tracepoint
+ *
+ * Creates a new tracepoint on a provider
+ */
+VALUE
+tracepoint_initialize(VALUE self, VALUE provider, VALUE id, VALUE vargs);
+
+/*
+ * call-seq:
+ *    tracepoint.fire(*vargs) -> true
+ *
+ * Fires data for the tracepoint to be probed
+ */
+VALUE
+tracepoint_fire(VALUE self, VALUE vargs);
+
+/*
+ * call-seq:
+ *    tracepoint.enabled? -> true
+ *
+ * Checks if the tracepoint is enabled, indicating it is being traced
+ */
+VALUE
+tracepoint_enabled(VALUE self);
+
+// Allocate a static_tracing_tracepoint_type struct for ruby memory management
+VALUE
+static_tracing_tracepoint_alloc(VALUE klass);
+
+#endif //STATIC_TRACING_TRACEPOINT_H

data/lib/ruby-static-tracing.rb

@@ -1,26 +1,81 @@
+# frozen_string_literal: true
+
+require 'logger'
+
 require 'ruby-static-tracing/version'
 require 'ruby-static-tracing/platform'
+require 'ruby-static-tracing/provider'
+require 'ruby-static-tracing/tracepoint'
+require 'ruby-static-tracing/configuration'
+require 'ruby-static-tracing/tracers'
 
 # 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
 
+  BaseError = Class.new(StandardError)
+  USDTError = Class.new(BaseError)
+  InternalError = Class.new(BaseError)
+
+  attr_accessor :logger
+
+  self.logger = Logger.new(STDERR)
+
+  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
+
+  # Efficiently return the current monotonic clocktime.
+  # Wraps libc clock_gettime
+  # The overhead of this is tested to be on the order of 10 microseconds under normal conditions
+  # You should inline this method in your tracer to avoid an extra method call.
+  def nsec
+    Process.clock_gettime(Process::CLOCK_MONOTONIC, :nanosecond)
+  end
+
   # Should indicate if static tracing is enabled - a global constant
   def enabled?
+    !!@enabled
   end
 
   # Overwrite the definition of all functions that are enabled
   # with a wrapped version that has tracing enabled
-  def enable
+  def enable!
+    tracers.each(&:enable!)
+    @enabled = true
   end
 
   # Overwrite the definition of all functions to their original definition,
   # no longer wrapping them
-  def disable
+  def disable!
+    @enabled = false
+  end
+
+  # Retrieves a hash of all registered providers
+  def providers
+    @providers ||= {}
+  end
+
+  def tracers
+    @tracers ||= []
+  end
+
+  def toggle_tracing!
+    enabled? ? disable! : enable!
+  end
+
+  def configure
+    yield Configuration.instance
   end
 end
 
 # FIXME add signal handlers to enable-disable on specific process signals
 # within a trap handler.
 # Specify default signals, but allow these to be overidden for easier integration
+
+# This loads the actual C extension, we might want to guard it
+# for cases where the extension isn't yet built
+require 'ruby-static-tracing/ruby_static_tracing' if StaticTracing::Platform.linux?

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require 'singleton'
+
+module StaticTracing
+  class Configuration
+    module Modes
+      ON = 'ON'
+      OFF = 'OFF'
+      SIGNAL = 'SIGNAL'
+
+      module SIGNALS
+        SIGPROF = 'PROF'
+      end
+    end
+
+    class << self
+      def instance
+        @instance ||= new
+      end
+    end
+
+    attr_reader :mode, :signal
+
+    def initialize
+      @mode = Modes::SIGNAL
+      @signal = Modes::SIGNALS::SIGPROF
+      enable_trap
+    end
+
+    def mode=(new_mode)
+      handle_old_mode
+      @mode = new_mode
+      handle_new_mode
+    end
+
+    def signal=(new_signal)
+      disable_trap
+      @signal = new_signal
+      enable_trap
+    end
+
+    def add_tracer(tracer)
+      StaticTracing.tracers << tracer
+    end
+
+    private
+
+    def handle_old_mode
+      disable_trap if @mode == Modes::SIGNAL
+    end
+
+    def handle_new_mode
+      if @mode == Modes::SIGNAL
+        enable_trap
+      elsif @mode == Modes::ON
+        StaticTracing.enable!
+      elsif @mode == Modes::OFF
+        StaticTracing.disable!
+      end
+    end
+
+    def disable_trap
+      Signal.trap(@signal, 'DEFAULT')
+    end
+
+    def enable_trap
+      Signal.trap(@signal) { StaticTracing.toggle_tracing! }
+    end
+  end
+end

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

@@ -1,5 +1,11 @@
+# frozen_string_literal: true
+
 module StaticTracing
-  def self.linux?
-    true
+  module Platform
+    extend self
+
+    def linux?
+      /linux/.match(RUBY_PLATFORM)
+    end
   end
 end

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module StaticTracing
+  class Provider #:nodoc:
+    attr_accessor :name
+    class ProviderNotFound < StandardError; end
+
+    class << self
+      def register(namespace)
+        providers[namespace] ||= new(namespace)
+      end
+
+      def fetch(namespace)
+        providers.fetch(namespace) do
+          raise ProviderNotFound
+        end
+      end
+
+      private
+
+      def providers
+        @providers ||= {}
+      end
+    end
+
+    attr_reader :namespace
+
+    def initialize(namespace)
+      if StaticTracing::Platform.linux?
+        provider_initialize(namespace)
+      else
+        StaticTracing.issue_disabled_tracepoints_warning
+      end
+      @namespace = namespace
+    end
+
+    def add_tracepoint(method_name, *args)
+      Tracepoint.new(namespace, method_name, *args)
+    end
+
+# FIXME - how to store list of tracepoints on provider? Allocate map in C?
+#    def tracepoints
+#      []
+#    end
+    def enable
+    end
+
+    def disable
+    end
+
+    # FIXME add binding to check if enabled
+    def enabled?
+    end
+
+    def destroy
+    end
+
+    def provider_initialize(*)
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module StaticTracing
+  class Tracepoint #:nodoc:
+
+    class InvalidArgumentError < StandardError; end
+    class InvalidArgType < StandardError; end
+
+    VALID_ARGS_TYPES = [Integer, String]
+
+    attr_reader :provider, :name, :args
+
+    def initialize(provider, name, *args)
+      @provider = provider
+      @name = name
+      validate_args(args)
+      @args = args
+
+      if StaticTracing::Platform.linux?
+        tracepoint_initialize(provider, name, args)
+      else
+        StaticTracing.issue_disabled_tracepoints_warning
+      end
+    end
+
+    def fire(*values)
+      values.each_with_index do |arg, i|
+        raise InvalidArgumentError unless arg.is_a?(args[i])
+      end
+    end
+
+    def enabled?
+    end
+
+    private
+
+    def validate_args(values)
+      raise InvalidArgType unless values.all? { |value|  VALID_ARGS_TYPES.include?(value) }
+    end
+  end
+end

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

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative 'tracers/latency_tracer'

data/lib/ruby-static-tracing/tracers/concerns/latency_tracer.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'ruby-static-tracing/tracers/latency_tracer'
+
+module StaticTracing
+  module Tracers
+    module Concerns
+      module LatencyTracer
+        def self.included(base)
+          methods = base.public_instance_methods(false)
+          StaticTracing::Tracers::LatencyTracer.register(base, methods)
+        end
+      end
+    end
+  end
+end

data/lib/ruby-static-tracing/tracers/latency_tracer.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+require 'unmixer'
+
+using Unmixer
+
+module StaticTracing
+  module Tracers
+    class LatencyTracer
+      class LatencyModuleGenerator < Module
+        def initialize(provider, methods)
+          methods.each do |method|
+            define_method(method) do |*args, &block|
+              start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC, :nanosecond)
+              result = super(*args, &block)
+              duration = Process.clock_gettime(Process::CLOCK_MONOTONIC, :nanosecond) - start_time
+              LatencyTracer.fire_tracepoint(provider, method, duration)
+              result
+            end
+          end
+        end
+      end
+
+      class << self
+        def register(klass, method_names, provider: nil)
+          provider ||= underscore(klass.name)
+          latency_module = LatencyModuleGenerator.new(provider, Array(method_names))
+          modified_classes[klass] = latency_module
+        end
+
+        def enable!
+          modified_classes.each do |klass, latency_module|
+            klass.prepend latency_module
+          end
+        end
+
+        def disable!
+          modified_classes.each do |klass, latency_module|
+            klass.instance_eval { unprepend latency_module }
+          end
+        end
+
+        def fire_tracepoint(provider, name, duration)
+          return
+          tracepoint(provider, name).fire(name, duration)
+        end
+
+        private
+
+        def tracepoint(provider, name)
+          @tracepoints[name] ||= StaticTracing::Tracepoint.new(provider, name, String, Interger)
+        end
+
+        def modified_classes
+          @modified_classes ||= {}
+        end
+
+        def underscore(class_name)
+          class_name.gsub(/::/, '_').
+          gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+          gsub(/([a-z\d])([A-Z])/,'\1_\2').
+          tr("-", "_").
+          downcase
+        end
+      end
+    end
+  end
+end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module StaticTracing
-  VERSION = '0.0.1'
+  VERSION = '0.0.2'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-static-tracing
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Dale Hamel
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-03-21 00:00:00.000000000 Z
+date: 2019-04-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -38,6 +38,48 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: '11.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: "    A Ruby C extension that enables defining static tracepoints\n    from
   within a ruby context. \n"
 email: dale.hamel@srvthe.net
@@ -47,9 +89,20 @@ extensions:
 extra_rdoc_files: []
 files:
 - ext/ruby-static-tracing/extconf.rb
+- ext/ruby-static-tracing/linux/provider.c
+- ext/ruby-static-tracing/linux/provider.h
 - ext/ruby-static-tracing/linux/ruby_static_tracing.c
+- ext/ruby-static-tracing/linux/ruby_static_tracing.h
+- ext/ruby-static-tracing/linux/tracepoint.c
+- ext/ruby-static-tracing/linux/tracepoint.h
 - lib/ruby-static-tracing.rb
+- lib/ruby-static-tracing/configuration.rb
 - lib/ruby-static-tracing/platform.rb
+- lib/ruby-static-tracing/provider.rb
+- lib/ruby-static-tracing/tracepoint.rb
+- lib/ruby-static-tracing/tracers.rb
+- lib/ruby-static-tracing/tracers/concerns/latency_tracer.rb
+- lib/ruby-static-tracing/tracers/latency_tracer.rb
 - lib/ruby-static-tracing/version.rb
 homepage: https://github.com/dalehamel/ruby-static-tracing
 licenses:
@@ -71,7 +124,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.9
+rubygems_version: 2.6.8
 signing_key: 
 specification_version: 4
 summary: USDT tracing for Ruby