rotoscope 0.3.0.pre.3 → 0.3.0.pre.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f45130c1218060c685c57b16ad4adadcccd40ee2
-  data.tar.gz: aeb4fd036a4a795396a4a8746eb3ab1033040c6f
+  metadata.gz: f4fd8393cc33b1bc131fd9f8b59f5445df3ba615
+  data.tar.gz: e4dbe71f46625cc11039cf3fc2a97eae80226f35
 SHA512:
-  metadata.gz: c58c3b03672d6f2c84906f4eb4e6598bbd0e0c6844e6e13df35d18025567b7f60ed367d8ca630a3738011ecee6b7c5e359009b4034810004a2f2b0f29a4c4d03
-  data.tar.gz: a0b993814e3ce2f1621c71433f9171cf51e595ce8c81e2f7f11ccc951e41ee15e7e96bc0391f7a11f051eb0ab7afa4bebf4ee9bc99dd3568d64c4ccee31aaada
+  metadata.gz: 2516f3ec80a5de3fca9cfdb241e085fbb93cd8a29ad75dc050a210971547b59b530866aab8120bd8c142f219ce12137a8a569ea40cb6a4a76775b385ecb5c670
+  data.tar.gz: 0ed7735ef3e1a6bb3126ad2e79d72d7d3fc0c51b313a9b0d211e14755a51e7997df7e1aa5170c84f6b966329bf2f5d56bb7b39de6f127e240bcffef65926c292

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-entity_whitelist-nil-flatten-false)
-  - [`new`](#rotoscopenewdest-entity_whitelist-nil-flatten-false)
+  - [`trace`](#rotoscopetracedest-blacklist--flatten-false)
+  - [`new`](#rotoscopenewdest-blacklist--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, entity_whitelist: nil, flatten: false)`
+#### `Rotoscope::trace(dest, blacklist: [], flatten: false)`
 
-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>`.
+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>`.
 
 ```ruby
 Rotoscope.trace(dest) { |rs| ... }
 # or...
-Rotoscope.trace(dest, entity_whitelist: ["Foo", "Bar"], flatten: true) { |rs| ... }
+Rotoscope.trace(dest, blacklist: ["/.gem/"], flatten: true) { |rs| ... }
 ```
 
-#### `Rotoscope::new(dest, entity_whitelist: nil, flatten: false)`
+#### `Rotoscope::new(dest, blacklist: [], 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, entity_whitelist: ["Foo", "Bar"], flatten: true)
+rs = Rotoscope.new(dest, blacklist: ["/.gem/"], flatten: true)
 ```
 
 ---

data/ext/rotoscope/rotoscope.c

@@ -37,9 +37,12 @@ static const char *evflag2name(rb_event_flag_t evflag) {
   }
 }
 
-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 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 VALUE class_path(VALUE klass) {
@@ -123,14 +126,10 @@ static void log_trace_event(FILE *stream, rs_tracepoint_t *trace) {
 unsigned char output_buffer[LOG_BUFFER_SIZE];
 static void log_trace_event_with_caller(FILE *stream,
                                         rs_stack_frame_t *stack_frame,
+                                        rs_stack_frame_t *caller_frame,
                                         rs_strmemo_t **call_memo) {
-  rs_stack_frame_t *caller = stack_frame->caller;
-  while (caller->blacklisted) {
-    caller = caller->caller;
-  }
-
   snprintf((char *)output_buffer, LOG_BUFFER_SIZE, RS_FLATTENED_CSV_FORMAT "\n",
-           RS_FLATTENED_CSV_VALUES(&stack_frame->tp, &caller->tp));
+           RS_FLATTENED_CSV_VALUES(&stack_frame->tp, &caller_frame->tp));
 
   if (rs_strmemo_uniq(call_memo, output_buffer)) {
     fputs((char *)output_buffer, stream);
@@ -151,38 +150,38 @@ static void event_hook(VALUE tpval, void *data) {
   rb_event_flag_t event_flag = rb_tracearg_event_flag(trace_arg);
 
   rs_callsite_t trace_path;
+  bool blacklisted;
   if (event_flag & EVENT_CALL) {
     trace_path = tracearg_path(trace_arg);
+    blacklisted = rejected_path(trace_path.filepath, config);
   } 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,
     };
+    blacklisted = call_frame->blacklisted;
   }
 
   rs_tracepoint_t trace = extract_full_tracevals(trace_arg, &trace_path);
   if (!strcmp("Rotoscope", StringValueCStr(trace.entity))) return;
 
-  bool blacklisted;
   if (event_flag & EVENT_CALL) {
-    blacklisted = rejected_entity(trace.entity, config);
     rs_stack_push(&config->stack, trace, blacklisted);
   } else {
-    blacklisted = rs_stack_peek(&config->stack)->blacklisted;
     rs_stack_pop(&config->stack);
   }
   if (blacklisted) return;
 
   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;
-      }
+      rs_stack_frame_t *caller = rs_stack_peek(&config->stack);
+      do {
+        caller = rs_stack_below(&config->stack, caller);
+      } while (caller && caller->blacklisted);
       if (caller) {
         log_trace_event_with_caller(config->log, rs_stack_peek(&config->stack),
-                                    &config->call_memo);
+                                    caller, &config->call_memo);
       }
     }
   } else {
@@ -215,7 +214,6 @@ 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);
 }
 
@@ -223,6 +221,7 @@ 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);
 }
 
@@ -231,7 +230,6 @@ 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();
@@ -245,25 +243,42 @@ static Rotoscope *get_config(VALUE self) {
   return config;
 }
 
-bool blacklisted_root(Rotoscope *config) {
-  return !NIL_P(config->entity_whitelist);
+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++;
+  }
 }
 
 VALUE initialize(int argc, VALUE *argv, VALUE self) {
   Rotoscope *config = get_config(self);
-  VALUE output_path, entity_whitelist, flatten;
+  VALUE output_path, blacklist, flatten;
 
-  rb_scan_args(argc, argv, "12", &output_path, &entity_whitelist, &flatten);
+  rb_scan_args(argc, argv, "12", &output_path, &blacklist, &flatten);
   Check_Type(output_path, T_STRING);
 
-  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);
-    }
+  if (!NIL_P(blacklist)) {
+    copy_blacklist(config, blacklist);
   }
 
   config->flatten_output = RTEST(flatten);
@@ -281,7 +296,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, blacklisted_root(config));
+  rs_stack_init(&config->stack, STACK_CAPACITY);
   config->call_memo = NULL;
   config->state = RS_OPEN;
   return self;
@@ -299,7 +314,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));
+    rs_stack_reset(&config->stack);
   }
 
   return Qnil;

data/ext/rotoscope/rotoscope.h

@@ -48,7 +48,8 @@ typedef struct {
   FILE *log;
   VALUE log_path;
   VALUE tracepoint;
-  VALUE entity_whitelist;
+  const char **blacklist;
+  unsigned long blacklist_size;
   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, bool blacklisted) {
+static void insert_root_node(rs_stack_t *stack) {
   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, bool blacklisted) {
                         .method_name = rb_unknown_str,
                         .method_level = UNKNOWN_STR,
                         .lineno = 0};
-  rs_stack_push(stack, root_trace, blacklisted);
+  rs_stack_push(stack, root_trace, false);
 }
 
 static void resize_buffer(rs_stack_t *stack) {
@@ -37,10 +37,8 @@ rs_stack_frame_t rs_stack_push(rs_stack_t *stack, rs_tracepoint_t trace,
     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, .blacklisted = blacklisted};
+  rs_stack_frame_t new_frame =
+      (rs_stack_frame_t){.tp = trace, .blacklisted = blacklisted};
 
   stack->contents[++stack->top] = new_frame;
   return new_frame;
@@ -64,9 +62,21 @@ rs_stack_frame_t *rs_stack_peek(rs_stack_t *stack) {
   return &stack->contents[stack->top];
 }
 
-void rs_stack_reset(rs_stack_t *stack, bool blacklisted_root) {
+rs_stack_frame_t *rs_stack_below(rs_stack_t *stack, rs_stack_frame_t *frame) {
+  if (frame < stack->contents || frame > stack->contents + stack->top) {
+    fprintf(stderr, "Invalid stack frame (bottom: %p, frame: %p, top: %p)\n",
+            stack->contents, frame, &stack->contents[stack->top]);
+    exit(1);
+  } else if (stack->contents == frame) {
+    return NULL;
+  } else {
+    return frame - 1;
+  }
+}
+
+void rs_stack_reset(rs_stack_t *stack) {
   stack->top = -1;
-  insert_root_node(stack, blacklisted_root);
+  insert_root_node(stack);
 }
 
 void rs_stack_free(rs_stack_t *stack) {
@@ -76,14 +86,13 @@ void rs_stack_free(rs_stack_t *stack) {
   stack->capacity = 0;
 }
 
-void rs_stack_init(rs_stack_t *stack, unsigned int capacity,
-                   bool blacklisted_root) {
+void rs_stack_init(rs_stack_t *stack, unsigned int capacity) {
   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, blacklisted_root);
+  insert_root_node(stack);
 }
 
 void rs_stack_mark(rs_stack_t *stack) {

data/ext/rotoscope/stack.h

@@ -8,7 +8,6 @@
 typedef struct rs_stack_frame_t {
   struct rs_tracepoint_t tp;
   bool blacklisted;
-  struct rs_stack_frame_t *caller;
 } rs_stack_frame_t;
 
 typedef struct {
@@ -17,14 +16,15 @@ typedef struct {
   rs_stack_frame_t *contents;
 } rs_stack_t;
 
-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_init(rs_stack_t *stack, unsigned int capacity);
+void rs_stack_reset(rs_stack_t *stack);
 void rs_stack_free(rs_stack_t *stack);
 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);
 rs_stack_frame_t *rs_stack_peek(rs_stack_t *stack);
+rs_stack_frame_t *rs_stack_below(rs_stack_t *stack, rs_stack_frame_t *frame);
 void rs_stack_mark(rs_stack_t *stack);
 
 #endif

data/lib/rotoscope.rb

@@ -6,12 +6,12 @@ require 'csv'
 
 class Rotoscope
   class << self
-    def new(output_path, entity_whitelist: nil, flatten: false)
-      super(output_path, entity_whitelist, flatten)
+    def new(output_path, blacklist: [], flatten: false)
+      super(output_path, blacklist, flatten)
     end
 
-    def trace(dest, entity_whitelist: nil, flatten: false, &block)
-      config = { entity_whitelist: entity_whitelist, flatten: flatten }
+    def trace(dest, blacklist: [], flatten: false, &block)
+      config = { blacklist: blacklist, 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, entity_whitelist: config[:entity_whitelist], flatten: config[:flatten])
+      rs = Rotoscope.new(dest_path, blacklist: config[:blacklist], 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.3"
+  VERSION = "0.3.0.pre.4"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rotoscope
 version: !ruby/object:Gem::Version
-  version: 0.3.0.pre.3
+  version: 0.3.0.pre.4
 platform: ruby
 authors:
 - Jahfer Husain