rotoscope 0.3.0.pre.2 → 0.3.0.pre.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 214bc0f95d10e738330ccf96ad98195588ce2fed
-  data.tar.gz: c8be5f0941288a7a5242e830b17c98de16935022
+  metadata.gz: f45130c1218060c685c57b16ad4adadcccd40ee2
+  data.tar.gz: aeb4fd036a4a795396a4a8746eb3ab1033040c6f
 SHA512:
-  metadata.gz: 0af5d811380da0de299478d7176a09308c1c2ff3a54ea77be54df01e4c34213d8208407b30a90ef34b19d07395c34e2b08395db7a2ba0b0eb783dff8c039b5a8
-  data.tar.gz: 577ec0a7a6bfc747bc3cde9d80b854aab30cd4804f60ad844273b917741c78f8900d043e87b4eb9a0905884c421e282e0cfe991a62d37ebfef6b7906114bb10d
+  metadata.gz: c58c3b03672d6f2c84906f4eb4e6598bbd0e0c6844e6e13df35d18025567b7f60ed367d8ca630a3738011ecee6b7c5e359009b4034810004a2f2b0f29a4c4d03
+  data.tar.gz: a0b993814e3ce2f1621c71433f9171cf51e595ce8c81e2f7f11ccc951e41ee15e7e96bc0391f7a11f051eb0ab7afa4bebf4ee9bc99dd3568d64c4ccee31aaada

data/README.md

@@ -85,8 +85,8 @@ IO,write,instance,example/flattened_dog.rb,11,IO,puts,instance
 ## API
 
 - [Public Class Methods](#public-class-methods)
-  - [`trace`](#rotoscopetracedest-blacklist--flatten-false)
-  - [`new`](#rotoscopenewdest-blacklist)
+  - [`trace`](#rotoscopetracedest-entity_whitelist-nil-flatten-false)
+  - [`new`](#rotoscopenewdest-entity_whitelist-nil-flatten-false)
 - [Public Instance Methods](#public-instance-methods)
   - [`trace`](#rotoscopetraceblock)
   - [`start_trace`](#rotoscopestart_trace)
@@ -101,23 +101,23 @@ IO,write,instance,example/flattened_dog.rb,11,IO,puts,instance
 
 ### Public Class Methods
 
-#### `Rotoscope::trace(dest, blacklist: [], flatten: false)`
+#### `Rotoscope::trace(dest, entity_whitelist: nil, flatten: false)`
 
-Writes all calls and returns of methods to `dest`, except for those whose filepath contains any entry in `blacklist`. `dest` is either a filename or an `IO`. The `flatten` option reduces the output data to a deduplicated list of method invocations and their caller, instead of all `call` and `return` events. Methods invoked at the top of the trace will have a caller entity of `<ROOT>` and a caller method name of `<UNKNOWN>`.
+Writes all calls and returns of methods to `dest`, except for those whose entity doesn't contain any entry in a provided `entity_whitelist`. `dest` is either a filename or an `IO`. The `flatten` option reduces the output data to a deduplicated list of method invocations and their caller, instead of all `call` and `return` events. Methods invoked at the top of the trace will have a caller entity of `<ROOT>` and a caller method name of `<UNKNOWN>`.
 
 ```ruby
 Rotoscope.trace(dest) { |rs| ... }
 # or...
-Rotoscope.trace(dest, blacklist: ["/.gem/"], flatten: true) { |rs| ... }
+Rotoscope.trace(dest, entity_whitelist: ["Foo", "Bar"], flatten: true) { |rs| ... }
 ```
 
-#### `Rotoscope::new(dest, blacklist: [], flatten: false)`
+#### `Rotoscope::new(dest, entity_whitelist: nil, flatten: false)`
 
 Same interface as `Rotoscope::trace`, but returns a `Rotoscope` instance, allowing fine-grain control via `Rotoscope#start_trace` and `Rotoscope#stop_trace`.
 ```ruby
 rs = Rotoscope.new(dest)
 # or...
-rs = Rotoscope.new(dest, blacklist: ["/.gem/"], flatten: true)
+rs = Rotoscope.new(dest, entity_whitelist: ["Foo", "Bar"], flatten: true)
 ```
 
 ---

data/ext/rotoscope/callsite.c

@@ -4,43 +4,6 @@
 
 VALUE empty_ruby_string;
 
-// Need the cfp field from this internal ruby structure.
-struct rb_trace_arg_struct {
-  // unused fields needed to make sure the cfp is at the
-  // correct offset
-  rb_event_flag_t unused1;
-  void *unused2;
-  void *cfp;
-  // rest of fields are unused
-};
-
-size_t ruby_control_frame_size;
-
-// We depend on MRI to store ruby control frames as an array
-// to determine the control frame size, which is used here to
-// get the caller's control frame
-static void *caller_cfp(void *cfp) {
-  return ((char *)cfp) + ruby_control_frame_size;
-}
-
-static VALUE dummy(VALUE self, VALUE first) {
-  if (first == Qtrue) {
-    rb_funcall(self, rb_intern("dummy"), 1, Qfalse);
-  }
-  return Qnil;
-}
-
-static void trace_control_frame_size(VALUE tpval, void *data) {
-  void **cfps = data;
-  rb_trace_arg_t *trace_arg = rb_tracearg_from_tracepoint(tpval);
-
-  if (cfps[0] == NULL) {
-    cfps[0] = trace_arg->cfp;
-  } else if (cfps[1] == NULL) {
-    cfps[1] = trace_arg->cfp;
-  }
-}
-
 rs_callsite_t c_callsite(rb_trace_arg_t *trace_arg) {
   VALUE path = rb_tracearg_path(trace_arg);
   return (rs_callsite_t){
@@ -50,29 +13,25 @@ rs_callsite_t c_callsite(rb_trace_arg_t *trace_arg) {
 }
 
 rs_callsite_t ruby_callsite(rb_trace_arg_t *trace_arg) {
-  void *old_cfp = trace_arg->cfp;
-
-  // Ruby uses trace_arg->cfp to get the path and line number
-  trace_arg->cfp = caller_cfp(trace_arg->cfp);
-  rs_callsite_t callsite = c_callsite(trace_arg);
-  trace_arg->cfp = old_cfp;
+  VALUE frames[2];
+  int lines[2];
+  // There is currently a bug in rb_profile_frames that
+  // causes the start argument to effectively always
+  // act as if it were 0, so we need to also get the top
+  // frame.
+  if (rb_profile_frames(0, 2, frames, lines) < 2) {
+    return (rs_callsite_t){
+        .filepath = empty_ruby_string, .lineno = 0,
+    };
+  }
 
-  return callsite;
+  return (rs_callsite_t){
+      .filepath = rb_profile_frame_path(frames[1]), .lineno = lines[1],
+  };
 }
 
 void init_callsite() {
   empty_ruby_string = rb_str_new_literal("");
   RB_OBJ_FREEZE(empty_ruby_string);
   rb_global_variable(&empty_ruby_string);
-
-  VALUE tmp_obj = rb_funcall(rb_cObject, rb_intern("new"), 0);
-  rb_define_singleton_method(tmp_obj, "dummy", dummy, 1);
-
-  char *cfps[2] = {NULL, NULL};
-  VALUE tracepoint = rb_tracepoint_new(Qnil, RUBY_EVENT_C_CALL,
-                                       trace_control_frame_size, &cfps);
-  rb_tracepoint_enable(tracepoint);
-  rb_funcall(tmp_obj, rb_intern("dummy"), 1, Qtrue);
-  rb_tracepoint_disable(tracepoint);
-  ruby_control_frame_size = (size_t)cfps[0] - (size_t)cfps[1];
 }

data/ext/rotoscope/rotoscope.c

@@ -13,8 +13,8 @@
 #include "strmemo.h"
 #include "tracepoint.h"
 
-VALUE cRotoscope, cTracePoint, cInstructionSeq;
-ID id_initialize, id_of, id_label;
+VALUE cRotoscope, cTracePoint;
+ID id_initialize;
 
 static unsigned long gettid() {
   return NUM2ULONG(rb_obj_id(rb_thread_current()));
@@ -37,12 +37,9 @@ static const char *evflag2name(rb_event_flag_t evflag) {
   }
 }
 
-static bool rejected_path(VALUE path, Rotoscope *config) {
-  for (unsigned long i = 0; i < config->blacklist_size; i++) {
-    if (strstr(StringValueCStr(path), config->blacklist[i])) return true;
-  }
-
-  return false;
+static bool rejected_entity(VALUE entity, Rotoscope *config) {
+  if (NIL_P(config->entity_whitelist)) return false;
+  return rb_hash_lookup(config->entity_whitelist, entity) != Qtrue;
 }
 
 static VALUE class_path(VALUE klass) {
@@ -108,6 +105,7 @@ static rs_tracepoint_t extract_full_tracevals(rb_trace_arg_t *trace_arg,
 
   VALUE method_name = tracearg_method_name(trace_arg);
   VALUE filepath = callsite->filepath;
+
   return (rs_tracepoint_t){.event = evflag2name(event_flag),
                            .entity = method_owner.name,
                            .filepath = filepath,
@@ -118,58 +116,30 @@ static rs_tracepoint_t extract_full_tracevals(rb_trace_arg_t *trace_arg,
 
 static bool in_fork(Rotoscope *config) { return config->pid != getpid(); }
 
-static VALUE unsafe_obj_method(VALUE argv) {
-  VALUE *args = (VALUE *)argv;
-  return rb_obj_method(args[0], args[1]);
-}
-static VALUE nil_method(VALUE *args) { return Qnil; }
-
-static bool endof_block_method(rb_trace_arg_t *trace_arg) {
-  VALUE method_id = rb_tracearg_method_id(trace_arg);
-  if (NIL_P(method_id)) return false;
-
-  VALUE self = rb_tracearg_self(trace_arg);
-  VALUE argv[2] = {self, method_id};
-  VALUE method = rb_rescue2(unsafe_obj_method, (VALUE)&argv, nil_method,
-                            (VALUE)&argv, rb_eNameError, (VALUE)0);
-  if (NIL_P(method)) return false;
-
-  VALUE iseq = rb_funcall(cInstructionSeq, id_of, 1, method);
-  if (!RTEST(iseq)) return false;
-
-  VALUE label = rb_funcall(iseq, id_label, 0);
-  char *label_str = StringValueCStr(label);
-  return strncmp(VM_BLOCK_PREFIX, label_str, strlen(VM_BLOCK_PREFIX)) == 0;
+static void log_trace_event(FILE *stream, rs_tracepoint_t *trace) {
+  fprintf(stream, RS_CSV_FORMAT "\n", RS_CSV_VALUES(trace));
 }
 
 unsigned char output_buffer[LOG_BUFFER_SIZE];
-static void log_trace_event_with_caller(FILE *stream, rs_strmemo_t **call_memo,
-                                        rs_stack_frame_t frame) {
-  snprintf((char *)output_buffer, LOG_BUFFER_SIZE, RS_FLATTENED_CSV_FORMAT "\n",
-           RS_FLATTENED_CSV_VALUES(frame));
-  if (rs_strmemo_uniq(call_memo, (unsigned char *)output_buffer)) {
-    fputs((char *)output_buffer, stream);
+static void log_trace_event_with_caller(FILE *stream,
+                                        rs_stack_frame_t *stack_frame,
+                                        rs_strmemo_t **call_memo) {
+  rs_stack_frame_t *caller = stack_frame->caller;
+  while (caller->blacklisted) {
+    caller = caller->caller;
   }
-}
 
-static void log_trace_event(FILE *stream, rs_tracepoint_t trace) {
-  fprintf(stream, RS_CSV_FORMAT "\n", RS_CSV_VALUES(trace));
-}
-
-static bool invalid_stack_return(rs_stack_t *stack, rs_tracepoint_t *trace) {
-  rs_stack_frame_t *last_frame = rs_stack_peek(stack);
-  return !rs_raw_tracepoint_cmp(&trace->raw, &last_frame->tp.raw);
-}
+  snprintf((char *)output_buffer, LOG_BUFFER_SIZE, RS_FLATTENED_CSV_FORMAT "\n",
+           RS_FLATTENED_CSV_VALUES(&stack_frame->tp, &caller->tp));
 
-static void copy_filepath_from_caller(rs_stack_t *stack,
-                                      rs_tracepoint_t *trace) {
-  rs_stack_frame_t *last_frame = rs_stack_peek(stack);
-  trace->filepath = last_frame->tp.filepath;
-  trace->lineno = last_frame->tp.lineno;
+  if (rs_strmemo_uniq(call_memo, output_buffer)) {
+    fputs((char *)output_buffer, stream);
+  }
 }
 
 static void event_hook(VALUE tpval, void *data) {
   Rotoscope *config = (Rotoscope *)data;
+
   if (config->tid != gettid()) return;
   if (in_fork(config)) {
     rb_tracepoint_disable(config->tracepoint);
@@ -179,41 +149,44 @@ static void event_hook(VALUE tpval, void *data) {
 
   rb_trace_arg_t *trace_arg = rb_tracearg_from_tracepoint(tpval);
   rb_event_flag_t event_flag = rb_tracearg_event_flag(trace_arg);
-  rs_callsite_t trace_path = tracearg_path(trace_arg);
-  rs_raw_tracepoint_t raw_trace = rs_raw_from_tracepoint(tpval);
-
-  if (rejected_path(trace_path.filepath, config)) {
-    if (METHOD_CALL_P(event_flag)) return;
-    // We must ensure the event being blacklisted has correct filepath set,
-    // since block-method returns always point one level too high in the stack.
-
-    // Does this match the last caller?
-    rs_stack_frame_t *last_frame = rs_stack_peek(&config->stack);
-    if (!rs_raw_tracepoint_cmp(&raw_trace, &last_frame->tp.raw)) return;
-    // Are we dealing with a block return in wrong context?
-    if (!endof_block_method(trace_arg)) return;
+
+  rs_callsite_t trace_path;
+  if (event_flag & EVENT_CALL) {
+    trace_path = tracearg_path(trace_arg);
+  } else {
+    if (rs_stack_empty(&config->stack)) return;
+    rs_stack_frame_t *call_frame = rs_stack_peek(&config->stack);
+    trace_path = (rs_callsite_t){
+        .filepath = call_frame->tp.filepath, .lineno = call_frame->tp.lineno,
+    };
   }
 
   rs_tracepoint_t trace = extract_full_tracevals(trace_arg, &trace_path);
-  trace.raw = raw_trace;
-
   if (!strcmp("Rotoscope", StringValueCStr(trace.entity))) return;
 
-  rs_stack_frame_t frame;
-  if (METHOD_CALL_P(event_flag)) {
-    frame = rs_stack_push(&config->stack, trace);
+  bool blacklisted;
+  if (event_flag & EVENT_CALL) {
+    blacklisted = rejected_entity(trace.entity, config);
+    rs_stack_push(&config->stack, trace, blacklisted);
   } else {
-    if (invalid_stack_return(&config->stack, &trace)) return;
-    if (endof_block_method(trace_arg)) {
-      copy_filepath_from_caller(&config->stack, &trace);
-    }
+    blacklisted = rs_stack_peek(&config->stack)->blacklisted;
     rs_stack_pop(&config->stack);
   }
+  if (blacklisted) return;
 
-  if (!config->flatten_output) {
-    return log_trace_event(config->log, trace);
-  } else if (METHOD_CALL_P(event_flag)) {
-    log_trace_event_with_caller(config->log, &config->call_memo, frame);
+  if (config->flatten_output) {
+    if (event_flag & EVENT_CALL) {
+      rs_stack_frame_t *caller = rs_stack_peek(&config->stack)->caller;
+      while (caller && caller->blacklisted) {
+        caller = caller->caller;
+      }
+      if (caller) {
+        log_trace_event_with_caller(config->log, rs_stack_peek(&config->stack),
+                                    &config->call_memo);
+      }
+    }
+  } else {
+    log_trace_event(config->log, &trace);
   }
 }
 
@@ -242,6 +215,7 @@ static void close_log_handle(Rotoscope *config) {
 static void rs_gc_mark(Rotoscope *config) {
   rb_gc_mark(config->log_path);
   rb_gc_mark(config->tracepoint);
+  rb_gc_mark(config->entity_whitelist);
   rs_stack_mark(&config->stack);
 }
 
@@ -249,7 +223,6 @@ void rs_dealloc(Rotoscope *config) {
   close_log_handle(config);
   rs_stack_free(&config->stack);
   rs_strmemo_free(config->call_memo);
-  xfree(config->blacklist);
   xfree(config);
 }
 
@@ -258,6 +231,7 @@ static VALUE rs_alloc(VALUE klass) {
   VALUE self =
       Data_Make_Struct(klass, Rotoscope, rs_gc_mark, rs_dealloc, config);
   config->log_path = Qnil;
+  config->entity_whitelist = Qnil;
   config->tracepoint = rb_tracepoint_new(Qnil, EVENT_CALL | EVENT_RETURN,
                                          event_hook, (void *)config);
   config->pid = getpid();
@@ -271,42 +245,25 @@ static Rotoscope *get_config(VALUE self) {
   return config;
 }
 
-void copy_blacklist(Rotoscope *config, VALUE blacklist) {
-  Check_Type(blacklist, T_ARRAY);
-
-  size_t blacklist_malloc_size =
-      RARRAY_LEN(blacklist) * sizeof(*config->blacklist);
-
-  for (long i = 0; i < RARRAY_LEN(blacklist); i++) {
-    VALUE ruby_string = RARRAY_AREF(blacklist, i);
-    Check_Type(ruby_string, T_STRING);
-    blacklist_malloc_size += RSTRING_LEN(ruby_string) + 1;
-  }
-
-  config->blacklist = ruby_xmalloc(blacklist_malloc_size);
-  config->blacklist_size = RARRAY_LEN(blacklist);
-  char *str = (char *)(config->blacklist + config->blacklist_size);
-
-  for (unsigned long i = 0; i < config->blacklist_size; i++) {
-    VALUE ruby_string = RARRAY_AREF(blacklist, i);
-
-    config->blacklist[i] = str;
-    memcpy(str, RSTRING_PTR(ruby_string), RSTRING_LEN(ruby_string));
-    str += RSTRING_LEN(ruby_string);
-    *str = '\0';
-    str++;
-  }
+bool blacklisted_root(Rotoscope *config) {
+  return !NIL_P(config->entity_whitelist);
 }
 
 VALUE initialize(int argc, VALUE *argv, VALUE self) {
   Rotoscope *config = get_config(self);
-  VALUE output_path, blacklist, flatten;
+  VALUE output_path, entity_whitelist, flatten;
 
-  rb_scan_args(argc, argv, "12", &output_path, &blacklist, &flatten);
+  rb_scan_args(argc, argv, "12", &output_path, &entity_whitelist, &flatten);
   Check_Type(output_path, T_STRING);
 
-  if (!NIL_P(blacklist)) {
-    copy_blacklist(config, blacklist);
+  if (!NIL_P(entity_whitelist)) {
+    Check_Type(entity_whitelist, T_ARRAY);
+    config->entity_whitelist = rb_hash_new();
+    for (long i = 0; i < RARRAY_LEN(entity_whitelist); i++) {
+      VALUE item = RARRAY_AREF(entity_whitelist, i);
+      Check_Type(item, T_STRING);
+      rb_hash_aset(config->entity_whitelist, item, Qtrue);
+    }
   }
 
   config->flatten_output = RTEST(flatten);
@@ -324,7 +281,7 @@ VALUE initialize(int argc, VALUE *argv, VALUE self) {
   else
     write_csv_header(config->log, RS_CSV_HEADER);
 
-  rs_stack_init(&config->stack, STACK_CAPACITY);
+  rs_stack_init(&config->stack, STACK_CAPACITY, blacklisted_root(config));
   config->call_memo = NULL;
   config->state = RS_OPEN;
   return self;
@@ -342,6 +299,7 @@ VALUE rotoscope_stop_trace(VALUE self) {
   if (rb_tracepoint_enabled_p(config->tracepoint)) {
     rb_tracepoint_disable(config->tracepoint);
     config->state = RS_OPEN;
+    rs_stack_reset(&config->stack, blacklisted_root(config));
   }
 
   return Qnil;
@@ -361,7 +319,6 @@ VALUE rotoscope_mark(int argc, VALUE *argv, VALUE self) {
 
   Rotoscope *config = get_config(self);
   if (config->log != NULL && !in_fork(config)) {
-    rs_stack_reset(&config->stack, STACK_CAPACITY);
     rs_strmemo_free(config->call_memo);
     fprintf(config->log, "--- %s\n", StringValueCStr(str));
   }
@@ -396,13 +353,9 @@ VALUE rotoscope_state(VALUE self) {
 }
 
 void Init_rotoscope(void) {
-  VALUE cRubyVm = rb_const_get(rb_cObject, rb_intern("RubyVM"));
-  cInstructionSeq = rb_const_get(cRubyVm, rb_intern("InstructionSequence"));
   cTracePoint = rb_const_get(rb_cObject, rb_intern("TracePoint"));
 
   id_initialize = rb_intern("initialize");
-  id_of = rb_intern("of");
-  id_label = rb_intern("label");
 
   cRotoscope = rb_define_class("Rotoscope", rb_cObject);
   rb_define_alloc_func(cRotoscope, rs_alloc);

data/ext/rotoscope/rotoscope.h

@@ -7,14 +7,10 @@
 
 #define EVENT_CALL (RUBY_EVENT_CALL | RUBY_EVENT_C_CALL)
 #define EVENT_RETURN (RUBY_EVENT_RETURN | RUBY_EVENT_C_RETURN)
-#define METHOD_CALL_P(event) event &EVENT_CALL
-#define METHOD_RETURN_P(event) event &EVENT_RETURN
 
 #define CLASS_METHOD "class"
 #define INSTANCE_METHOD "instance"
 
-#define VM_BLOCK_PREFIX "block "
-
 #define STACK_CAPACITY 500
 #define LOG_BUFFER_SIZE 1000
 
@@ -22,24 +18,24 @@
 #define _RS_COMMON_CSV_HEADER "entity,method_name,method_level,filepath,lineno"
 #define _RS_COMMON_CSV_FORMAT "\"%s\",\"%s\",%s,\"%s\",%d"
 #define _RS_COMMON_CSV_VALUES(trace)  \
-  StringValueCStr(trace.entity),      \
-  StringValueCStr(trace.method_name), \
-  trace.method_level,                 \
-  StringValueCStr(trace.filepath),    \
-  trace.lineno
+  StringValueCStr((trace)->entity),      \
+  StringValueCStr((trace)->method_name), \
+  (trace)->method_level,                 \
+  StringValueCStr((trace)->filepath),    \
+  (trace)->lineno
 
 #define RS_CSV_HEADER "event," _RS_COMMON_CSV_HEADER
 #define RS_CSV_FORMAT "%s," _RS_COMMON_CSV_FORMAT
-#define RS_CSV_VALUES(trace) trace.event, _RS_COMMON_CSV_VALUES(trace)
+#define RS_CSV_VALUES(trace) trace->event, _RS_COMMON_CSV_VALUES(trace)
 
 #define RS_FLATTENED_CSV_HEADER \
   _RS_COMMON_CSV_HEADER ",caller_entity,caller_method_name,caller_method_level"
 #define RS_FLATTENED_CSV_FORMAT _RS_COMMON_CSV_FORMAT ",\"%s\",\"%s\",%s"
-#define RS_FLATTENED_CSV_VALUES(frame)           \
-  _RS_COMMON_CSV_VALUES(frame.tp),               \
-  StringValueCStr(frame.caller->tp.entity),      \
-  StringValueCStr(frame.caller->tp.method_name), \
-  frame.caller->tp.method_level
+#define RS_FLATTENED_CSV_VALUES(trace, caller_trace) \
+  _RS_COMMON_CSV_VALUES(trace),               \
+  StringValueCStr((caller_trace)->entity),      \
+  StringValueCStr((caller_trace)->method_name), \
+  (caller_trace)->method_level
 // clang-format on
 
 typedef enum {
@@ -52,8 +48,7 @@ typedef struct {
   FILE *log;
   VALUE log_path;
   VALUE tracepoint;
-  const char **blacklist;
-  unsigned long blacklist_size;
+  VALUE entity_whitelist;
   bool flatten_output;
   pid_t pid;
   unsigned long tid;

data/ext/rotoscope/stack.c

@@ -5,7 +5,7 @@
 #include "ruby.h"
 #include "tracepoint.h"
 
-static void insert_root_node(rs_stack_t *stack) {
+static void insert_root_node(rs_stack_t *stack, bool blacklisted) {
   VALUE rb_unknown_str = rb_str_new_cstr(UNKNOWN_STR);
   rs_tracepoint_t root_trace =
       (rs_tracepoint_t){.event = UNKNOWN_STR,
@@ -14,7 +14,7 @@ static void insert_root_node(rs_stack_t *stack) {
                         .method_name = rb_unknown_str,
                         .method_level = UNKNOWN_STR,
                         .lineno = 0};
-  rs_stack_push(stack, root_trace);
+  rs_stack_push(stack, root_trace, blacklisted);
 }
 
 static void resize_buffer(rs_stack_t *stack) {
@@ -31,15 +31,16 @@ bool rs_stack_full(rs_stack_t *stack) {
 
 bool rs_stack_empty(rs_stack_t *stack) { return stack->top < 0; }
 
-rs_stack_frame_t rs_stack_push(rs_stack_t *stack, rs_tracepoint_t trace) {
+rs_stack_frame_t rs_stack_push(rs_stack_t *stack, rs_tracepoint_t trace,
+                               bool blacklisted) {
   if (rs_stack_full(stack)) {
     resize_buffer(stack);
   }
 
   rs_stack_frame_t *caller =
       rs_stack_empty(stack) ? NULL : rs_stack_peek(stack);
-  rs_stack_frame_t new_frame =
-      (rs_stack_frame_t){.tp = trace, .caller = caller};
+  rs_stack_frame_t new_frame = (rs_stack_frame_t){
+      .tp = trace, .caller = caller, .blacklisted = blacklisted};
 
   stack->contents[++stack->top] = new_frame;
   return new_frame;
@@ -63,9 +64,9 @@ rs_stack_frame_t *rs_stack_peek(rs_stack_t *stack) {
   return &stack->contents[stack->top];
 }
 
-void rs_stack_reset(rs_stack_t *stack, unsigned int capacity) {
+void rs_stack_reset(rs_stack_t *stack, bool blacklisted_root) {
   stack->top = -1;
-  insert_root_node(stack);
+  insert_root_node(stack, blacklisted_root);
 }
 
 void rs_stack_free(rs_stack_t *stack) {
@@ -75,13 +76,14 @@ void rs_stack_free(rs_stack_t *stack) {
   stack->capacity = 0;
 }
 
-void rs_stack_init(rs_stack_t *stack, unsigned int capacity) {
+void rs_stack_init(rs_stack_t *stack, unsigned int capacity,
+                   bool blacklisted_root) {
   rs_stack_frame_t *contents = ALLOC_N(rs_stack_frame_t, capacity);
   stack->contents = contents;
   stack->capacity = capacity;
   stack->top = -1;
 
-  insert_root_node(stack);
+  insert_root_node(stack, blacklisted_root);
 }
 
 void rs_stack_mark(rs_stack_t *stack) {

data/ext/rotoscope/stack.h

@@ -1,6 +1,5 @@
 #ifndef _INC_ROTOSCOPE_STACK_H_
 #define _INC_ROTOSCOPE_STACK_H_
-
 #include <stdbool.h>
 #include "tracepoint.h"
 
@@ -8,6 +7,7 @@
 
 typedef struct rs_stack_frame_t {
   struct rs_tracepoint_t tp;
+  bool blacklisted;
   struct rs_stack_frame_t *caller;
 } rs_stack_frame_t;
 
@@ -17,10 +17,10 @@ typedef struct {
   rs_stack_frame_t *contents;
 } rs_stack_t;
 
-void rs_stack_init(rs_stack_t *stack, unsigned int capacity);
-void rs_stack_reset(rs_stack_t *stack, unsigned int capacity);
+void rs_stack_init(rs_stack_t *stack, unsigned int capacity, bool blacklisted_root);
+void rs_stack_reset(rs_stack_t *stack, bool blacklisted_root);
 void rs_stack_free(rs_stack_t *stack);
-rs_stack_frame_t rs_stack_push(rs_stack_t *stack, rs_tracepoint_t trace);
+rs_stack_frame_t rs_stack_push(rs_stack_t *stack, rs_tracepoint_t trace, bool backlisted);
 bool rs_stack_empty(rs_stack_t *stack);
 bool rs_stack_full(rs_stack_t *stack);
 rs_stack_frame_t rs_stack_pop(rs_stack_t *stack);

data/ext/rotoscope/tracepoint.c

@@ -1,26 +1,8 @@
 #include "tracepoint.h"
 #include "ruby.h"
 
-rs_raw_tracepoint_t rs_raw_from_tracepoint(VALUE tracepoint) {
-  rb_trace_arg_t *trace_arg = rb_tracearg_from_tracepoint(tracepoint);
-  return (rs_raw_tracepoint_t){
-      .self = rb_tracearg_self(trace_arg),
-      .method_id = rb_tracearg_method_id(trace_arg),
-  };
-}
-
-void rs_raw_tracepoint_mark(rs_raw_tracepoint_t *tracepoint) {
-  rb_gc_mark(tracepoint->method_id);
-  rb_gc_mark(tracepoint->self);
-}
-
 void rs_tracepoint_mark(rs_tracepoint_t *tracepoint) {
   rb_gc_mark(tracepoint->entity);
   rb_gc_mark(tracepoint->filepath);
   rb_gc_mark(tracepoint->method_name);
-  rs_raw_tracepoint_mark(&tracepoint->raw);
-}
-
-bool rs_raw_tracepoint_cmp(rs_raw_tracepoint_t *tp1, rs_raw_tracepoint_t *tp2) {
-  return (tp1->method_id == tp2->method_id) && (tp1->self == tp2->self);
 }

data/ext/rotoscope/tracepoint.h

@@ -1,18 +1,7 @@
 #ifndef _INC_ROTOSCOPE_TRACEPOINT_H_
 #define _INC_ROTOSCOPE_TRACEPOINT_H_
 
-#include <ruby.h>
-#include <ruby/debug.h>
-#include <stdbool.h>
-
-typedef struct rs_raw_tracepoint_t {
-  VALUE method_id;
-  VALUE self;
-} rs_raw_tracepoint_t;
-
-rs_raw_tracepoint_t rs_raw_from_tracepoint(VALUE tracepoint);
-void rs_raw_tracepoint_mark(rs_raw_tracepoint_t *tracepoint);
-bool rs_raw_tracepoint_cmp(rs_raw_tracepoint_t *tp1, rs_raw_tracepoint_t *tp2);
+#include "ruby.h"
 
 typedef struct rs_tracepoint_t {
   const char *event;
@@ -21,7 +10,6 @@ typedef struct rs_tracepoint_t {
   VALUE method_name;
   const char *method_level;
   unsigned int lineno;
-  rs_raw_tracepoint_t raw;
 } rs_tracepoint_t;
 
 void rs_tracepoint_mark(rs_tracepoint_t *tracepoint);

data/lib/rotoscope.rb

@@ -6,12 +6,12 @@ require 'csv'
 
 class Rotoscope
   class << self
-    def new(output_path, blacklist: [], flatten: false)
-      super(output_path, blacklist, flatten)
+    def new(output_path, entity_whitelist: nil, flatten: false)
+      super(output_path, entity_whitelist, flatten)
     end
 
-    def trace(dest, blacklist: [], flatten: false, &block)
-      config = { blacklist: blacklist, flatten: flatten }
+    def trace(dest, entity_whitelist: nil, flatten: false, &block)
+      config = { entity_whitelist: entity_whitelist, flatten: flatten }
       if dest.is_a?(String)
         event_trace(dest, config, &block)
       else
@@ -45,7 +45,7 @@ class Rotoscope
     end
 
     def event_trace(dest_path, config)
-      rs = Rotoscope.new(dest_path, blacklist: config[:blacklist], flatten: config[:flatten])
+      rs = Rotoscope.new(dest_path, entity_whitelist: config[:entity_whitelist], flatten: config[:flatten])
       rs.trace { yield rs }
       rs
     ensure

data/lib/rotoscope/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 class Rotoscope
-  VERSION = "0.3.0.pre.2"
+  VERSION = "0.3.0.pre.3"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rotoscope
 version: !ruby/object:Gem::Version
-  version: 0.3.0.pre.2
+  version: 0.3.0.pre.3
 platform: ruby
 authors:
 - Jahfer Husain
@@ -120,7 +120,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.14
+rubygems_version: 2.5.2.1
 signing_key: 
 specification_version: 4
 summary: Tracing Ruby