ruby-static-tracing 0.0.13 → 0.0.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0c9f06dac9e5b53283124140623a3677c85d32730f390716d7b2385fb20fbed4
-  data.tar.gz: daa93d708d1e42075fa5cb3043d2aabefac3bd9fd42161defd8481a0fb7d60fa
+  metadata.gz: 7ac00c672308f4c2f3f12935d4a64ed1a0ac190c09a32f0b6ef5f684bd05d4d1
+  data.tar.gz: c1ea10f2f75a1f230789d4dd093af6760a2f949be0cec0b5f30fe66c8b1dc8ad
 SHA512:
-  metadata.gz: b742bc905d5ff7b8bad1b5d5fd1561b349ab2480c242402e93983f9b7fd6c0f5a1ff97055fb35be15ce80bad3db3f9d4b50596d04474f5f54aa7b52401932b2b
-  data.tar.gz: d4f394274ac8a1d763913ed4ec57fd20f321f9dbe153b8eb87c321a3d6e2204c14a184e5952e8a66b0f45a9588c49fe33f4a4ee3d9183463d42431c4f6e1c0e4
+  metadata.gz: d619816b75f523a10ef9e7f4ecfbc5d5067483661a9931d0199a012406313ab8fa3092ca71bf65fcfdc3e89ac222e6fa7b8848f66d965ab042c0eb4a73c0edcc
+  data.tar.gz: c1c98d614ec92e106a08b83492ec5f9a8c8017a749d394950ee633148927277a470111b5f918eaa16053fc5099e391807baa5ff5cf6c56c32420f193b11bb806

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

@@ -1,45 +1,46 @@
 #include "provider.h"
 
-static const rb_data_type_t
-static_tracing_provider_type;
+static const rb_data_type_t static_tracing_provider_type;
 
 // Forward decls
-static const char*
-check_name_arg(VALUE name);
+static const char *check_name_arg(VALUE name);
 
 /*
   Wraps usdt_create_provider from libusdt.h
 */
 VALUE
-provider_initialize(VALUE self, VALUE name)
-{
+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_"
+  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)
-{
+// // 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;
+  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)
-{
+provider_enable(VALUE self) {
   static_tracing_provider_t *res = NULL;
-  TypedData_Get_Struct(self, static_tracing_provider_t, &static_tracing_provider_type, res);
+  TypedData_Get_Struct(self, static_tracing_provider_t,
+                       &static_tracing_provider_type, res);
   return usdt_provider_enable(res->usdt_provider) == 0 ? Qtrue : Qfalse;
 }
 
@@ -47,10 +48,10 @@ provider_enable(VALUE self)
  Wraps usdt_provider_disable from libusdt.h
 */
 VALUE
-provider_disable(VALUE self)
-{
+provider_disable(VALUE self) {
   static_tracing_provider_t *res = NULL;
-  TypedData_Get_Struct(self, static_tracing_provider_t, &static_tracing_provider_type, res);
+  TypedData_Get_Struct(self, static_tracing_provider_t,
+                       &static_tracing_provider_type, res);
   return usdt_provider_disable(res->usdt_provider) == 0 ? Qtrue : Qfalse;
 }
 
@@ -58,27 +59,24 @@ provider_disable(VALUE self)
  Wraps usdt_provider_free from libusdt.h
 */
 VALUE
-provider_destroy(VALUE self)
-{
+provider_destroy(VALUE self) {
   static_tracing_provider_t *res = NULL;
-  TypedData_Get_Struct(self, static_tracing_provider_t, &static_tracing_provider_type, res);
+  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_alloc(VALUE klass) {
   static_tracing_provider_t *res;
-  VALUE obj = TypedData_Make_Struct(klass, static_tracing_provider_t, &static_tracing_provider_type, 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)
-{
+static const char *check_name_arg(VALUE name) {
   const char *c_name_str = NULL;
 
   if (TYPE(name) != T_SYMBOL && TYPE(name) != T_STRING) {
@@ -93,36 +91,26 @@ check_name_arg(VALUE name)
   return c_name_str;
 }
 
-static inline void
-static_tracing_provider_mark(void *ptr)
-{
-  /* noop */
+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) {
+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)
-{
+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
-};
+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

@@ -56,7 +56,6 @@ provider_destroy(VALUE self);
 VALUE
 static_tracing_provider_alloc(VALUE klass);
 
-int
-provider_add_tracepoint_internal(VALUE self, usdt_probedef_t* probedef);
+int provider_add_tracepoint_internal(VALUE self, usdt_probedef_t *probedef);
 
-#endif //STATIC_TRACING_PROVIDER_H
+#endif // STATIC_TRACING_PROVIDER_H

data/ext/ruby-static-tracing/darwin/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
@@ -41,8 +40,8 @@ void Init_ruby_static_tracing()
   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, "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

@@ -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 char
-**check_vargs(int *argc, VALUE vargs);
+static char **check_vargs(int *argc, VALUE vargs);
 
-static void
-**check_fire_args(int *argc, VALUE vargs);
+static void **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
   char **args = check_vargs(&argc, vargs);
 
@@ -33,11 +27,15 @@ tracepoint_initialize(VALUE self, VALUE provider, VALUE name, VALUE vargs)
   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);
+  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);
+  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.
@@ -48,10 +46,10 @@ 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;
   void *args = check_fire_args(&argc, vargs);
 
@@ -60,16 +58,14 @@ tracepoint_fire(VALUE self, VALUE vargs)
 }
 
 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 usdt_is_enabled(res->usdt_tracepoint_def->probe) == 0 ? Qfalse : Qtrue;
 }
 
-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) {
@@ -84,9 +80,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) {
@@ -101,25 +95,22 @@ check_provider_arg(VALUE provider)
   return c_provider_str;
 }
 
-static char
-**check_vargs(int *argc, VALUE vargs)
-{
-  if(TYPE(vargs) == T_ARRAY)
-  {
+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);
+    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);
+    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")) {
@@ -135,7 +126,6 @@ static char
   }
 }
 
-
 /*
  * Yeah, returning a void ** array is a bit sketchy, but since
  * usdt_fire_probe takes a void **, that's what we'll give it.
@@ -145,42 +135,37 @@ static char
  * 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)
-  {
+ */
+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);
+    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);
     // FIXME check against registered argtypes here
-    for (int i = 0; i < *argc; i++)
-    {
+    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;
+      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;
+    return (void **)args;
   } else {
     printf("ERROR - array was expected\n");
     return NULL;
@@ -189,43 +174,33 @@ static void
 
 // 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};