rbtrace 0.1.0 → 0.2.0

data/ext/.gitignore

@@ -0,0 +1,4 @@
+Makefile
+*.bundle
+*.o
+*.so

data/ext/extconf.rb

@@ -5,4 +5,7 @@ if RUBY_PLATFORM =~ /linux/
   $defs.push("-DBUF_SIZE=256")
 end
 
+# warnings save lives
+$CFLAGS << " -Wall "
+
 create_makefile('rbtrace')

data/ext/rbtrace.c

@@ -17,8 +17,11 @@
 #include <ruby.h>
 
 #ifndef RUBY_VM
-#include <node.h>
+#include <env.h>
 #include <intern.h>
+#include <node.h>
+#define rb_sourcefile() (ruby_current_node ? ruby_current_node->nd_file : 0)
+#define rb_sourceline() (ruby_current_node ? nd_line(ruby_current_node) : 0)
 #endif
 
 #ifndef RSTRING_PTR
@@ -36,7 +39,13 @@ timeofday_usec()
   return (uint64_t)tv.tv_sec*1e6 + (uint64_t)tv.tv_usec;
 }
 
-#define MAX_EXPRS 10
+#define MAX_CALLS 32768 // up to this many stack frames examined in slow watch mode
+#define MAX_TRACERS 100 // max method tracers
+#define MAX_EXPRS 10    // max expressions per tracer
+#ifndef BUF_SIZE        // msgq buffer size
+#define BUF_SIZE 120
+#endif
+
 struct rbtracer_t {
   int id;
 
@@ -50,28 +59,54 @@ struct rbtracer_t {
 };
 typedef struct rbtracer_t rbtracer_t;
 
-#define MAX_TRACERS 100
-static rbtracer_t tracers[MAX_TRACERS];
-static unsigned int num_tracers = 0;
-
-key_t mqi_key, mqo_key;
-int mqi_id = -1, mqo_id = -1;
-
-#ifndef BUF_SIZE
-#define BUF_SIZE 120
-#endif
 
 struct event_msg {
   long mtype;
   char buf[BUF_SIZE];
 };
 
+
+static struct {
+  bool installed;
+
+  bool firehose;
+
+  bool slow;
+  uint64_t call_times[MAX_CALLS];
+  int num_calls;
+  uint32_t threshold;
+
+  unsigned int num;
+  rbtracer_t list[MAX_TRACERS];
+
+  key_t mqo_key;
+  key_t mqi_key;
+  int mqo_id;
+  int mqi_id;
+}
+rbtracer = {
+  .installed = false,
+
+  .firehose = false,
+
+  .slow = false,
+  .num_calls = 0,
+  .threshold = 250,
+
+  .num = 0,
+
+  .mqo_key = 0,
+  .mqi_key = 0,
+  .mqo_id = -1,
+  .mqi_id = -1
+};
+
 #define SEND_EVENT(format, ...) do {\
   uint64_t usec = timeofday_usec();\
   if (false) {\
     fprintf(stderr, "%" PRIu64 "," format, usec, __VA_ARGS__);\
     fprintf(stderr, "\n");\
-  } else {\
+  } else if (rbtracer.mqo_id != -1) {\
     struct event_msg msg;\
     int ret = -1, n = 0;\
     \
@@ -79,31 +114,16 @@ struct event_msg {
     snprintf(msg.buf, sizeof(msg.buf), "%" PRIu64 "," format, usec, __VA_ARGS__);\
     \
     for (n=0; n<10 && ret==-1; n++)\
-      ret = msgsnd(mqo_id, &msg, sizeof(msg)-sizeof(long), IPC_NOWAIT);\
+      ret = msgsnd(rbtracer.mqo_id, &msg, sizeof(msg)-sizeof(long), IPC_NOWAIT);\
     if (ret == -1) {\
       fprintf(stderr, "msgsnd(): %s\n", strerror(errno));\
       struct msqid_ds stat;\
-      msgctl(mqo_id, IPC_STAT, &stat);\
+      msgctl(rbtracer.mqo_id, IPC_STAT, &stat);\
       fprintf(stderr, "cbytes: %lu, qbytes: %lu, qnum: %lu\n", stat.msg_cbytes, stat.msg_qbytes, stat.msg_qnum);\
     }\
   }\
 } while (0)
 
-static int in_event_hook = 0;
-static bool event_hook_installed = false;
-
-#define MAX_CALLS 32768
-static struct {
-  bool enabled;
-  uint64_t call_times[ MAX_CALLS ];
-  int num_calls;
-  uint32_t threshold;
-} slow_tracer = {
-  .enabled = false,
-  .num_calls = 0,
-  .threshold = 250
-};
-
 static void
 #ifdef RUBY_VM
 event_hook(rb_event_flag_t event, VALUE data, VALUE self, ID mid, VALUE klass)
@@ -111,6 +131,8 @@ event_hook(rb_event_flag_t event, VALUE data, VALUE self, ID mid, VALUE klass)
 event_hook(rb_event_t event, NODE *node, VALUE self, ID mid, VALUE klass)
 #endif
 {
+  static int in_event_hook = 0;
+
   // do not re-enter this function
   // after this, must `goto out` instead of `return`
   if (in_event_hook) return;
@@ -129,35 +151,35 @@ event_hook(rb_event_t event, NODE *node, VALUE self, ID mid, VALUE klass)
   }
 
   // are we watching for any slow methods?
-  if (slow_tracer.enabled) {
+  if (rbtracer.slow) {
     uint64_t usec = timeofday_usec(), diff = 0;
 
     switch (event) {
       case RUBY_EVENT_C_CALL:
       case RUBY_EVENT_CALL:
-        if (slow_tracer.num_calls < MAX_CALLS)
-          slow_tracer.call_times[ slow_tracer.num_calls ] = usec;
+        if (rbtracer.num_calls < MAX_CALLS)
+          rbtracer.call_times[ rbtracer.num_calls ] = usec;
 
-        slow_tracer.num_calls++;
+        rbtracer.num_calls++;
         break;
 
       case RUBY_EVENT_C_RETURN:
       case RUBY_EVENT_RETURN:
-        if (slow_tracer.num_calls > 0) {
-          slow_tracer.num_calls--;
+        if (rbtracer.num_calls > 0) {
+          rbtracer.num_calls--;
 
-          if (slow_tracer.num_calls < MAX_CALLS)
-            diff = usec - slow_tracer.call_times[ slow_tracer.num_calls ];
+          if (rbtracer.num_calls < MAX_CALLS)
+            diff = usec - rbtracer.call_times[ rbtracer.num_calls ];
         }
         break;
     }
 
-    if (diff > slow_tracer.threshold * 1e3) {
+    if (diff > rbtracer.threshold * 1e3) {
       SEND_EVENT(
         "%s,-1,%" PRIu64 ",%d,%s,%d,%s",
         event == RUBY_EVENT_RETURN ? "slow" : "cslow",
         diff,
-        slow_tracer.num_calls,
+        rbtracer.num_calls,
         rb_id2name(mid),
         singleton,
         klass ? rb_class2name(singleton ? self : klass) : ""
@@ -167,28 +189,30 @@ event_hook(rb_event_t event, NODE *node, VALUE self, ID mid, VALUE klass)
     goto out;
   }
 
-  // are there specific methods we're waiting for?
-  if (num_tracers == 0) goto out;
-
   int i, n;
   rbtracer_t *tracer = NULL;
 
-  for (i=0, n=0; i<MAX_TRACERS && n<num_tracers; i++) {
-    if (tracers[i].query) {
-      n++;
+  if (!rbtracer.firehose) {
+    // are there specific methods we're waiting for?
+    if (rbtracer.num == 0) goto out;
+
+    for (i=0, n=0; i<MAX_TRACERS && n<rbtracer.num; i++) {
+      if (rbtracer.list[i].query) {
+        n++;
 
-      if (!tracers[i].mid || tracers[i].mid == mid) {
-        if (!tracers[i].klass || tracers[i].klass == klass) {
-          if (!tracers[i].self || tracers[i].self == self) {
-            tracer = &tracers[i];
+        if (!rbtracer.list[i].mid || rbtracer.list[i].mid == mid) {
+          if (!rbtracer.list[i].klass || rbtracer.list[i].klass == klass) {
+            if (!rbtracer.list[i].self || rbtracer.list[i].self == self) {
+              tracer = &rbtracer.list[i];
+            }
           }
         }
       }
     }
-  }
 
-  // no matching method tracer found, so bail!
-  if (!tracer) goto out;
+    // no matching method tracer found, so bail!
+    if (!tracer) goto out;
+  }
 
   switch (event) {
     case RUBY_EVENT_C_CALL:
@@ -196,31 +220,43 @@ event_hook(rb_event_t event, NODE *node, VALUE self, ID mid, VALUE klass)
       SEND_EVENT(
         "%s,%d,%s,%d,%s",
         event == RUBY_EVENT_CALL ? "call" : "ccall",
-        tracer->id,
+        tracer ? tracer->id : 255, // hax
         rb_id2name(mid),
         singleton,
         klass ? rb_class2name(singleton ? self : klass) : ""
       );
 
-      if (tracer->num_exprs) {
+      if (tracer && tracer->num_exprs) {
         for (i=0; i<tracer->num_exprs; i++) {
           char *expr = tracer->exprs[i];
           size_t len = strlen(expr);
-          VALUE str = Qnil, val = Qnil;
+
+          VALUE val = Qnil;
+          char buffer[len+50];
+          char *result = NULL;
 
           if (len == 4 && strcmp("self", expr) == 0) {
             val = rb_inspect(self);
 
+          } else if (len == 10 && strcmp("__source__", expr) == 0) {
+            snprintf(buffer, len+50, "\"%s:%d\"", rb_sourcefile(), rb_sourceline());
+            result = buffer;
+
+          } else if (len > 1 && expr[0] == '@') {
+            val = rb_inspect(rb_ivar_get(self, rb_intern(expr)));
+
           } else if (event == RUBY_EVENT_CALL) {
-            char code[len+50];
-            snprintf(code, len+50, "(begin; %s; rescue Exception => e; e; end).inspect", expr);
+            snprintf(buffer, len+50, "(begin; %s; rescue Exception => e; e; end).inspect", expr);
 
-            str = rb_str_new2(code);
+            VALUE str = rb_str_new2(buffer);
             val = rb_obj_instance_eval(1, &str, self);
           }
 
           if (RTEST(val) && TYPE(val) == T_STRING) {
-            char *result = RSTRING_PTR(val);
+            result = RSTRING_PTR(val);
+          }
+
+          if (result) {
             SEND_EVENT(
               "%s,%d,%d,%s",
               "exprval",
@@ -238,7 +274,7 @@ event_hook(rb_event_t event, NODE *node, VALUE self, ID mid, VALUE klass)
       SEND_EVENT(
         "%s,%d",
         event == RUBY_EVENT_RETURN ? "return" : "creturn",
-        tracer->id
+        tracer ? tracer->id : 255 // hax
       );
       break;
   }
@@ -250,7 +286,7 @@ out:
 static void
 event_hook_install()
 {
-  if (!event_hook_installed) {
+  if (!rbtracer.installed) {
     rb_add_event_hook(
       event_hook,
       RUBY_EVENT_CALL   | RUBY_EVENT_C_CALL |
@@ -259,16 +295,16 @@ event_hook_install()
       , 0
 #endif
     );
-    event_hook_installed = true;
+    rbtracer.installed = true;
   }
 }
 
 static void
 event_hook_remove()
 {
-  if (event_hook_installed) {
+  if (rbtracer.installed) {
     rb_remove_event_hook(event_hook);
-    event_hook_installed = false;
+    rbtracer.installed = false;
   }
 }
 
@@ -281,16 +317,16 @@ rbtracer_remove(char *query, int id)
 
   if (query) {
     for (i=0; i<MAX_TRACERS; i++) {
-      if (tracers[i].query) {
-        if (0 == strcmp(query, tracers[i].query)) {
-          tracer = &tracers[i];
+      if (rbtracer.list[i].query) {
+        if (0 == strcmp(query, rbtracer.list[i].query)) {
+          tracer = &rbtracer.list[i];
           break;
         }
       }
     }
   } else {
     if (id >= MAX_TRACERS) goto out;
-    tracer = &tracers[id];
+    tracer = &rbtracer.list[id];
   }
 
   if (tracer->query) {
@@ -308,8 +344,8 @@ rbtracer_remove(char *query, int id)
       tracer->num_exprs = 0;
     }
 
-    num_tracers--;
-    if (num_tracers == 0)
+    rbtracer.num--;
+    if (rbtracer.num == 0)
       event_hook_remove();
   }
 
@@ -325,9 +361,12 @@ out:
 static void
 rbtracer_remove_all()
 {
+  rbtracer.firehose = false;
+  rbtracer.slow = false;
+
   int i;
   for (i=0; i<MAX_TRACERS; i++) {
-    if (tracers[i].query) {
+    if (rbtracer.list[i].query) {
       rbtracer_remove(NULL, i);
     }
   }
@@ -340,11 +379,11 @@ rbtracer_add(char *query)
   int tracer_id = -1;
   rbtracer_t *tracer = NULL;
 
-  if (num_tracers >= MAX_TRACERS) goto out;
+  if (rbtracer.num >= MAX_TRACERS) goto out;
 
   for (i=0; i<MAX_TRACERS; i++) {
-    if (!tracers[i].query) {
-      tracer = &tracers[i];
+    if (!rbtracer.list[i].query) {
+      tracer = &rbtracer.list[i];
       tracer_id = i;
       break;
     }
@@ -389,10 +428,10 @@ rbtracer_add(char *query)
   tracer->query = strdup(query);
   tracer->num_exprs = 0;
 
-  if (num_tracers == 0)
+  if (rbtracer.num == 0)
     event_hook_install();
 
-  num_tracers++;
+  rbtracer.num++;
 
 out:
   SEND_EVENT(
@@ -411,7 +450,7 @@ rbtracer_add_expr(int id, char *expr)
   rbtracer_t *tracer = NULL;
 
   if (id >= MAX_TRACERS) goto out;
-  tracer = &tracers[id];
+  tracer = &rbtracer.list[id];
 
   if (tracer->query) {
     tracer_id = tracer->id;
@@ -434,10 +473,11 @@ out:
 static void
 rbtracer_watch(uint32_t threshold)
 {
-  if (!slow_tracer.enabled) {
-    slow_tracer.num_calls = 0;
-    slow_tracer.threshold = threshold;
-    slow_tracer.enabled = true;
+  if (!rbtracer.slow) {
+    rbtracer.num_calls = 0;
+    rbtracer.threshold = threshold;
+    rbtracer.firehose = false;
+    rbtracer.slow = true;
 
     event_hook_install();
   }
@@ -446,61 +486,83 @@ rbtracer_watch(uint32_t threshold)
 static void
 rbtracer_unwatch()
 {
-  if (slow_tracer.enabled) {
+  if (rbtracer.slow) {
     event_hook_remove();
 
-    slow_tracer.enabled = false;
+    rbtracer.firehose = false;
+    rbtracer.slow = false;
   }
 }
 
-static VALUE
-rbtrace(VALUE self, VALUE query)
+static void
+msgq_teardown()
 {
-  Check_Type(query, T_STRING);
-
-  char *str = RSTRING_PTR(query);
-  int tracer_id = -1;
-
-  tracer_id = rbtracer_add(str);
-  return tracer_id == -1 ? Qfalse : Qtrue;
+  if (rbtracer.mqo_id != -1) {
+    msgctl(rbtracer.mqo_id, IPC_RMID, NULL);
+    rbtracer.mqo_id = -1;
+    rbtracer.mqo_key = 0;
+  }
+  if (rbtracer.mqi_id != -1) {
+    msgctl(rbtracer.mqi_id, IPC_RMID, NULL);
+    rbtracer.mqi_id = -1;
+    rbtracer.mqi_key = 0;
+  }
 }
 
-static VALUE
-untrace(VALUE self, VALUE query)
+static void
+ruby_teardown(VALUE data)
 {
-  Check_Type(query, T_STRING);
-
-  char *str = RSTRING_PTR(query);
-  int tracer_id = -1;
-
-  tracer_id = rbtracer_remove(str, -1);
-  return tracer_id == -1 ? Qfalse : Qtrue;
+  msgq_teardown();
 }
 
 static void
-cleanup()
+msgq_setup()
 {
-  if (mqo_id != -1) {
-    msgctl(mqo_id, IPC_RMID, NULL);
-    mqo_id = -1;
-  }
-  if (mqi_id != -1) {
-    msgctl(mqi_id, IPC_RMID, NULL);
-    mqi_id = -1;
+  pid_t pid = getpid();
+
+  if (rbtracer.mqo_key != (key_t)pid ||
+      rbtracer.mqi_key != (key_t)-pid) {
+    msgq_teardown();
+  } else {
+    return;
   }
-}
 
-static void
-cleanup_ruby(VALUE data)
-{
-  cleanup();
+  rbtracer.mqo_key = (key_t) pid;
+  rbtracer.mqo_id  = msgget(rbtracer.mqo_key, 0666 | IPC_CREAT);
+
+  if (rbtracer.mqo_id == -1)
+    fprintf(stderr, "msgget() failed to create msgq\n");
+
+
+  rbtracer.mqi_key = (key_t) -pid;
+  rbtracer.mqi_id  = msgget(rbtracer.mqi_key, 0666 | IPC_CREAT);
+
+  if (rbtracer.mqi_id == -1)
+    fprintf(stderr, "msgget() failed to create msgq\n");
+
+  /*
+  struct msqid_ds stat;
+  int ret;
+
+  msgctl(rbtracer.mqo_id, IPC_STAT, &stat);
+  printf("cbytes: %lu, qbytes: %lu, qnum: %lu\n", stat.msg_cbytes, stat.msg_qbytes, stat.msg_qnum);
+
+  stat.msg_qbytes += 10;
+  ret = msgctl(rbtracer.mqo_id, IPC_SET, &stat);
+  printf("cbytes: %lu, qbytes: %lu, qnum: %lu\n", stat.msg_cbytes, stat.msg_qbytes, stat.msg_qnum);
+  printf("ret: %d, errno: %d\n", ret, errno);
+
+  msgctl(rbtracer.mqo_id, IPC_STAT, &stat);
+  printf("cbytes: %lu, qbytes: %lu, qnum: %lu\n", stat.msg_cbytes, stat.msg_qbytes, stat.msg_qnum);
+  */
 }
 
 static void
 sigurg(int signal)
 {
   static int last_tracer_id = -1; // hax
-  if (mqi_id == -1) return;
+  msgq_setup();
+  if (rbtracer.mqi_id == -1) return;
 
   struct event_msg msg;
   char *query = NULL;
@@ -511,7 +573,7 @@ sigurg(int signal)
     int ret = -1;
 
     for (n=0; n<10 && ret==-1; n++)
-      ret = msgrcv(mqi_id, &msg, sizeof(msg)-sizeof(long), 0, IPC_NOWAIT);
+      ret = msgrcv(rbtracer.mqi_id, &msg, sizeof(msg)-sizeof(long), 0, IPC_NOWAIT);
 
     if (ret == -1) {
       break;
@@ -528,8 +590,9 @@ sigurg(int signal)
         query = msg.buf + 4;
         rbtracer_remove(query, -1);
 
-      } else if (0 == strncmp("delall", msg.buf, 6)) {
-        rbtracer_remove_all();
+      } else if (0 == strncmp("firehose", msg.buf, 8)) {
+        rbtracer.firehose = true;
+        event_hook_install();
 
       } else if (0 == strncmp("addexpr,", msg.buf, 8)) {
         query = msg.buf + 8;
@@ -547,6 +610,9 @@ sigurg(int signal)
       } else if (0 == strncmp("unwatch", msg.buf, 7)) {
         rbtracer_unwatch();
 
+      } else if (0 == strncmp("detach", msg.buf, 6)) {
+        rbtracer_remove_all();
+
       }
     }
   }
@@ -555,39 +621,13 @@ sigurg(int signal)
 void
 Init_rbtrace()
 {
-  atexit(cleanup);
-  rb_set_end_proc(cleanup_ruby, 0);
+  // zero out tracer
+  memset(&rbtracer.list, 0, sizeof(rbtracer.list));
 
+  // catch signal telling us to read from the msgq
   signal(SIGURG, sigurg);
 
-  memset(&tracers, 0, sizeof(tracers));
-
-  mqo_key = (key_t) getpid();
-  mqo_id  = msgget(mqo_key, 0666 | IPC_CREAT);
-  if (mqo_id == -1)
-    rb_sys_fail("msgget");
-
-  mqi_key = (key_t) -getpid();
-  mqi_id  = msgget(mqi_key, 0666 | IPC_CREAT);
-  if (mqi_id == -1)
-    rb_sys_fail("msgget");
-
-  /*
-  struct msqid_ds stat;
-  int ret;
-
-  msgctl(mqo_id, IPC_STAT, &stat);
-  printf("cbytes: %lu, qbytes: %lu, qnum: %lu\n", stat.msg_cbytes, stat.msg_qbytes, stat.msg_qnum);
-
-  stat.msg_qbytes += 10;
-  ret = msgctl(mqo_id, IPC_SET, &stat);
-  printf("cbytes: %lu, qbytes: %lu, qnum: %lu\n", stat.msg_cbytes, stat.msg_qbytes, stat.msg_qnum);
-  printf("ret: %d, errno: %d\n", ret, errno);
-
-  msgctl(mqo_id, IPC_STAT, &stat);
-  printf("cbytes: %lu, qbytes: %lu, qnum: %lu\n", stat.msg_cbytes, stat.msg_qbytes, stat.msg_qnum);
-  */
-
-  rb_define_method(rb_cObject, "rbtrace", rbtrace, 1);
-  rb_define_method(rb_cObject, "untrace", untrace, 1);
+  // cleanup the msgq on exit
+  atexit(msgq_teardown);
+  rb_set_end_proc(ruby_teardown, 0);
 }