rotoscope 0.3.0.pre.7 → 0.3.0.pre.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: dc57c07b922488935b47e583d422a36d9fa32096
-  data.tar.gz: cd70207ab9f61bcd490506a5defc6c293dbec11d
+  metadata.gz: a13014ea4da609b9a22d6abf8bbd57d6f2d33ffe
+  data.tar.gz: 1d3c71e1673bfc4cc4adfec7e5041e66f0104999
 SHA512:
-  metadata.gz: 7c512251290df7ee37e72e0f130ca879da887f3ecdd206b60e9e4a361e422bf68daf6b6c42acbb1c20a40efaa4c7166334fc2e21d0df2e3dc1f9c722267b31c0
-  data.tar.gz: a5e1d3bdd7ae63147097154630aae6bb9c4153fa110be4fc1873cbce38f7d684a3e0f87cc1c80f4dfd811c04e21d21c8dcc5adad7de4afc91a977dc266ac0d41
+  metadata.gz: a2acdaacb7ee98c49c437ffd73e6444dbbf0c0b8dbeedad1edef839c3dde20ff9344a331b1747be6a4a306855dd818a094768dd16d091a41b70a1ff39636cd0d
+  data.tar.gz: f2e35df44720ea2c7d53c5c8c548b99867772d02fa5c6cd56d2b863d982c4635840d2c74b328c05053718aa264746d0f450f2e4168aa6a30bca4b377234160e7

data/.ruby-version

@@ -1 +1 @@
-2.3.3
+2.4.3

data/README.md

@@ -28,7 +28,7 @@ end
 log_file = File.expand_path('dog_trace.log')
 puts "Writing to #{log_file}..."
 
-Rotoscope.trace(log_file) do
+Rotoscope::CallLogger.trace(log_file) do
   dog1 = Dog.new
   dog1.bark
 end
@@ -38,131 +38,98 @@ The resulting method calls are saved in the specified `dest` in the order they w
 
 Sample output:
 
-```
-event,entity,method_name,method_level,filepath,lineno
-call,"Dog","new",class,"example/dog.rb",19
-call,"Dog","initialize",instance,"example/dog.rb",19
-return,"Dog","initialize",instance,"example/dog.rb",19
-return,"Dog","new",class,"example/dog.rb",19
-call,"Dog","bark",instance,"example/dog.rb",4
-call,"Noisemaker","speak",class,"example/dog.rb",10
-call,"Noisemaker","puts",class,"example/dog.rb",11
-call,"IO","puts",instance,"example/dog.rb",11
-call,"IO","write",instance,"example/dog.rb",11
-return,"IO","write",instance,"example/dog.rb",11
-call,"IO","write",instance,"example/dog.rb",11
-return,"IO","write",instance,"example/dog.rb",11
-return,"IO","puts",instance,"example/dog.rb",11
-return,"Noisemaker","puts",class,"example/dog.rb",11
-return,"Noisemaker","speak",class,"example/dog.rb",12
-return,"Dog","bark",instance,"example/dog.rb",6
-```
-
-If you're interested solely in the flattened caller/callee list, you can pass the `flatten` option to retrieve that instead. This step will also remove all duplicate lines, which can produce significantly smaller output on large codebases.
-
-```ruby
-# ... same code as above
-
-Rotoscope.trace(log_file, flatten: true) do
-  dog1 = Dog.new
-  dog1.bark
-end
-```
-
-Sample output:
-
 ```
 entity,method_name,method_level,filepath,lineno,caller_entity,caller_method_name,caller_method_level
-Dog,new,class,example/flattened_dog.rb,19,<ROOT>,<UNKNOWN>,<UNKNOWN>
-Dog,initialize,instance,example/flattened_dog.rb,19,Dog,new,class
-Dog,bark,instance,example/flattened_dog.rb,20,<ROOT>,<UNKNOWN>,<UNKNOWN>
-Noisemaker,speak,class,example/flattened_dog.rb,5,Dog,bark,instance
-Noisemaker,puts,class,example/flattened_dog.rb,11,Noisemaker,speak,class
-IO,puts,instance,example/flattened_dog.rb,11,Noisemaker,puts,class
-IO,write,instance,example/flattened_dog.rb,11,IO,puts,instance
+Dog,new,class,example/dog.rb,19,<ROOT>,<UNKNOWN>,<UNKNOWN>
+Dog,initialize,instance,example/dog.rb,19,Dog,new,class
+Dog,bark,instance,example/dog.rb,20,<ROOT>,<UNKNOWN>,<UNKNOWN>
+Noisemaker,speak,class,example/dog.rb,5,Dog,bark,instance
+Noisemaker,puts,class,example/dog.rb,11,Noisemaker,speak,class
+IO,puts,instance,example/dog.rb,11,Noisemaker,puts,class
+IO,write,instance,example/dog.rb,11,IO,puts,instance
+IO,write,instance,example/dog.rb,11,IO,puts,instance
 ```
 
 ## API
 
 - [Public Class Methods](#public-class-methods)
-  - [`trace`](#rotoscopetracedest-blacklist--flatten-false)
-  - [`new`](#rotoscopenewdest-blacklist--flatten-false)
+  - [`trace`](#rotoscopecallloggertracedest-blacklist-)
+  - [`new`](#rotoscopecallloggernewdest-blacklist-)
 - [Public Instance Methods](#public-instance-methods)
-  - [`trace`](#rotoscopetraceblock)
-  - [`start_trace`](#rotoscopestart_trace)
-  - [`stop_trace`](#rotoscopestop_trace)
-  - [`mark`](#rotoscopemarkstr--)
-  - [`close`](#rotoscopeclose)
-  - [`state`](#rotoscopestate)
-  - [`closed?`](#rotoscopeclosed)
-  - [`log_path`](#rotoscopelog_path)
+  - [`trace`](#rotoscopecallloggertraceblock)
+  - [`start_trace`](#rotoscopecallloggerstart_trace)
+  - [`stop_trace`](#rotoscopecallloggerstop_trace)
+  - [`mark`](#rotoscopecallloggermarkstr--)
+  - [`close`](#rotoscopecallloggerclose)
+  - [`state`](#rotoscopecallloggerstate)
+  - [`closed?`](#rotoscopecallloggerclosed)
 
 ---
 
 ### Public Class Methods
 
-#### `Rotoscope::trace(dest, blacklist: [], flatten: false)`
+#### `Rotoscope::CallLogger::trace(dest, blacklist: [])`
 
-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 of methods to `dest`, except for those whose filepath contains any entry in `blacklist`. `dest` is either a filename or an `IO`. 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| ... }
+Rotoscope::CallLogger.trace(dest) { |rs| ... }
 # or...
-Rotoscope.trace(dest, blacklist: ["/.gem/"], flatten: true) { |rs| ... }
+Rotoscope::CallLogger.trace(dest, blacklist: ["/.gem/"]) { |rs| ... }
 ```
 
-#### `Rotoscope::new(dest, blacklist: [], flatten: false)`
+#### `Rotoscope::CallLogger::new(dest, blacklist: [])`
 
-Same interface as `Rotoscope::trace`, but returns a `Rotoscope` instance, allowing fine-grain control via `Rotoscope#start_trace` and `Rotoscope#stop_trace`.
+Same interface as `Rotoscope::CallLogger::trace`, but returns a `Rotoscope::CallLogger` instance, allowing fine-grain control via `Rotoscope::CallLogger#start_trace` and `Rotoscope::CallLogger#stop_trace`.
 ```ruby
-rs = Rotoscope.new(dest)
+rs = Rotoscope::CallLogger.new(dest)
 # or...
-rs = Rotoscope.new(dest, blacklist: ["/.gem/"], flatten: true)
+rs = Rotoscope::CallLogger.new(dest, blacklist: ["/.gem/"])
 ```
 
 ---
 
 ### Public Instance Methods
 
-#### `Rotoscope#trace(&block)`
+#### `Rotoscope::CallLogger#trace(&block)`
 
-Similar to `Rotoscope::trace`, but does not need to create a file handle on invocation.
+Similar to `Rotoscope::CallLogger::trace`, but does not need to create a file handle on invocation.
 
 ```ruby
-rs = Rotoscope.new(dest)
+rs = Rotoscope::CallLogger.new(dest)
 rs.trace do |rotoscope|
   # code to trace...
 end
 ```
 
-#### `Rotoscope#start_trace`
+#### `Rotoscope::CallLogger#start_trace`
 
-Begins writing method calls and returns to the `dest` specified in the initializer.
+Begins writing method calls to the `dest` specified in the initializer.
 
 ```ruby
-rs = Rotoscope.new(dest)
+rs = Rotoscope::CallLogger.new(dest)
 rs.start_trace
 # code to trace...
 rs.stop_trace
 ```
 
-#### `Rotoscope#stop_trace`
+#### `Rotoscope::CallLogger#stop_trace`
 
-Stops writing method invocations to the `dest`. Subsequent calls to `Rotoscope#start_trace` may be invoked to resume tracing.
+Stops writing method invocations to the `dest`. Subsequent calls to `Rotoscope::CallLogger#start_trace` may be invoked to resume tracing.
 
 ```ruby
-rs = Rotoscope.new(dest)
+rs = Rotoscope::CallLogger.new(dest)
 rs.start_trace
 # code to trace...
 rs.stop_trace
 ```
 
-#### `Rotoscope#mark(str = "")`
+#### `Rotoscope::CallLogger#mark(str = "")`
 
  Inserts a marker '--- ' to divide output. Useful for segmenting multiple blocks of code that are being profiled. If `str` is provided, the line will be prefixed by '--- ', followed by the string passed.
 
 ```ruby
-rs = Rotoscope.new(dest)
+rs = Rotoscope::CallLogger.new(dest)
 rs.start_trace
 # code to trace...
 rs.mark('Something goes wrong here') # produces `--- Something goes wrong here` in the output
@@ -170,22 +137,22 @@ rs.mark('Something goes wrong here') # produces `--- Something goes wrong here`
 rs.stop_trace
 ```
 
-#### `Rotoscope#close`
+#### `Rotoscope::CallLogger#close`
 
-Flushes the buffer and closes the file handle. Once this is invoked, no more writes can be performed on the `Rotoscope` object. Sets `state` to `:closed`.
+Flushes the buffer and closes the file handle. Once this is invoked, no more writes can be performed on the `Rotoscope::CallLogger` object. Sets `state` to `:closed`.
 
 ```ruby
-rs = Rotoscope.new(dest)
+rs = Rotoscope::CallLogger.new(dest)
 rs.trace { |rotoscope| ... }
 rs.close
 ```
 
-#### `Rotoscope#state`
+#### `Rotoscope::CallLogger#state`
 
-Returns the current state of the Rotoscope object. Valid values are `:open`, `:tracing` and `:closed`.
+Returns the current state of the Rotoscope::CallLogger object. Valid values are `:open`, `:tracing` and `:closed`.
 
 ```ruby
-rs = Rotoscope.new(dest)
+rs = Rotoscope::CallLogger.new(dest)
 rs.state # :open
 rs.trace do
   rs.state # :tracing
@@ -194,24 +161,13 @@ rs.close
 rs.state # :closed
 ```
 
-#### `Rotoscope#closed?`
+#### `Rotoscope::CallLogger#closed?`
 
 Shorthand to check if the `state` is set to `:closed`.
 
 ```ruby
-rs = Rotoscope.new(dest)
+rs = Rotoscope::CallLogger.new(dest)
 rs.closed? # false
 rs.close
 rs.closed? # true
 ```
-
-
-#### `Rotoscope#log_path`
-
-Returns the output filepath set in the Rotoscope constructor.
-
-```ruby
-dest = '/foo/bar/rotoscope.csv'
-rs = Rotoscope.new(dest)
-rs.log_path # "/foo/bar/rotoscope.csv"
-```

data/Rakefile

@@ -35,4 +35,9 @@ Rake::TestTask.new 'test' do |t|
 end
 task test: :build
 
-task default: :test
+task :rubocop do
+  require 'rubocop/rake_task'
+  RuboCop::RakeTask.new
+end
+
+task default: [:test, :rubocop]

data/bin/fmt

@@ -1,7 +1,7 @@
 #! /usr/bin/env bash
 
 echo "Formatting C code..."
-find "$PWD" -iname lib/rotoscope/*.h -o -iname *.c | xargs clang-format -i -style=file
+find "$PWD/ext" -iname '*.c' -o -iname '*.h' | xargs clang-format -i -style=file
 
 echo "Formatting Ruby code..."
 bundle exec rubocop -a

data/dev.yml

@@ -1,7 +1,7 @@
 ---
 name: rotoscope
 up:
-  - ruby: 2.3.3
+  - ruby: 2.4.3
   - homebrew:
     - clang-format
   - bundler

data/ext/rotoscope/method_desc.c

@@ -0,0 +1,11 @@
+#include "method_desc.h"
+
+VALUE rs_method_class(rs_method_desc_t *method) {
+  return method->singleton_p ? method->receiver
+                             : rb_obj_class(method->receiver);
+}
+
+void rs_method_desc_mark(rs_method_desc_t *method) {
+  rb_gc_mark(method->receiver);
+  rb_gc_mark(method->id);
+}

data/ext/rotoscope/method_desc.h

@@ -0,0 +1,16 @@
+#ifndef _INC_ROTOSCOPE_METHOD_DESC_H_
+#define _INC_ROTOSCOPE_METHOD_DESC_H_
+
+#include "ruby.h"
+#include "stdbool.h"
+
+typedef struct rs_method_desc_t {
+  VALUE receiver;
+  VALUE id;
+  bool singleton_p;
+} rs_method_desc_t;
+
+VALUE rs_method_class(rs_method_desc_t *method);
+void rs_method_desc_mark(rs_method_desc_t *method);
+
+#endif

data/ext/rotoscope/rotoscope.c

@@ -9,39 +9,17 @@
 #include <sys/file.h>
 
 #include "callsite.h"
+#include "method_desc.h"
 #include "rotoscope.h"
 #include "stack.h"
-#include "tracepoint.h"
 
 VALUE cRotoscope, cTracePoint;
-ID id_initialize, id_gsub, id_close;
-VALUE str_quote, str_escaped_quote, str_header;
+ID id_initialize, id_call;
 
 static unsigned long gettid() {
   return NUM2ULONG(rb_obj_id(rb_thread_current()));
 }
 
-static const char *evflag2name(rb_event_flag_t evflag) {
-  switch (evflag) {
-    case RUBY_EVENT_CALL:
-    case RUBY_EVENT_C_CALL:
-      return "call";
-    case RUBY_EVENT_RETURN:
-    case RUBY_EVENT_C_RETURN:
-      return "return";
-    default:
-      return "unknown";
-  }
-}
-
-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) {
   VALUE cached_path = rb_class_path_cached(klass);
   if (!NIL_P(cached_path)) {
@@ -75,45 +53,18 @@ static rs_callsite_t tracearg_path(rb_trace_arg_t *trace_arg) {
   }
 }
 
-static rs_class_desc_t tracearg_class(rb_trace_arg_t *trace_arg) {
-  VALUE klass;
-  const char *method_level;
-  VALUE self = rb_tracearg_self(trace_arg);
-
-  if ((RB_TYPE_P(self, T_CLASS) || RB_TYPE_P(self, T_MODULE)) &&
-      SYM2ID(rb_tracearg_method_id(trace_arg)) != id_initialize) {
-    method_level = CLASS_METHOD;
-    klass = self;
-  } else {
-    method_level = INSTANCE_METHOD;
-    klass = rb_obj_class(self);
-  }
+static rs_method_desc_t called_method_desc(rb_trace_arg_t *trace_arg) {
+  VALUE receiver = rb_tracearg_self(trace_arg);
+  VALUE method_id = rb_tracearg_method_id(trace_arg);
+  bool singleton_p =
+      (RB_TYPE_P(receiver, T_CLASS) || RB_TYPE_P(receiver, T_MODULE)) &&
+      SYM2ID(method_id) != id_initialize;
 
-  return (rs_class_desc_t){
-      .name = class2str(klass), .method_level = method_level,
+  return (rs_method_desc_t){
+      .receiver = receiver, .id = method_id, .singleton_p = singleton_p,
   };
 }
 
-static VALUE tracearg_method_name(rb_trace_arg_t *trace_arg) {
-  return rb_sym2str(rb_tracearg_method_id(trace_arg));
-}
-
-static rs_tracepoint_t extract_full_tracevals(rb_trace_arg_t *trace_arg,
-                                              const rs_callsite_t *callsite) {
-  rs_class_desc_t method_owner = tracearg_class(trace_arg);
-  rb_event_flag_t event_flag = rb_tracearg_event_flag(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,
-                           .method_name = method_name,
-                           .method_level = method_owner.method_level,
-                           .lineno = callsite->lineno};
-}
-
 static bool in_fork(Rotoscope *config) { return config->pid != getpid(); }
 
 // The GC sweep step will turn objects with finalizers (e.g. rs_dealloc)
@@ -127,43 +78,8 @@ bool rotoscope_marked_for_garbage_collection(Rotoscope *config) {
   return RB_BUILTIN_TYPE(config->self) == RUBY_T_ZOMBIE;
 }
 
-VALUE escape_csv_string(VALUE string) {
-  if (!memchr(RSTRING_PTR(string), '"', RSTRING_LEN(string))) {
-    return string;
-  }
-  return rb_funcall(string, id_gsub, 2, str_quote, str_escaped_quote);
-}
-
-static void log_trace_event_with_caller(VALUE output_buffer, VALUE io,
-                                        rs_stack_frame_t *stack_frame,
-                                        rs_stack_frame_t *caller_frame) {
-  VALUE escaped_method_name = escape_csv_string(stack_frame->tp.method_name);
-  VALUE escaped_caller_method_name =
-      escape_csv_string(caller_frame->tp.method_name);
-
-  while (true) {
-    rb_str_modify(output_buffer);
-    long out_len = snprintf(
-        RSTRING_PTR(output_buffer), rb_str_capacity(output_buffer),
-        RS_CSV_FORMAT "\n",
-        RS_CSV_VALUES(&stack_frame->tp, &caller_frame->tp, escaped_method_name,
-                      escaped_caller_method_name));
-
-    if (out_len < RSTRING_LEN(output_buffer)) {
-      rb_str_set_len(output_buffer, out_len);
-      break;
-    }
-    rb_str_resize(output_buffer, out_len + 1);
-  }
-
-  RB_GC_GUARD(escaped_method_name);
-  RB_GC_GUARD(escaped_caller_method_name);
-
-  rb_io_write(io, output_buffer);
-}
-
 static void stop_tracing_on_cleanup(Rotoscope *config) {
-  if (config->state == RS_TRACING) {
+  if (config->tracing) {
     // During process cleanup, event hooks are removed and tracepoint may have
     // already have been GCed, so we need a sanity check before disabling the
     // tracepoint.
@@ -171,7 +87,7 @@ static void stop_tracing_on_cleanup(Rotoscope *config) {
         CLASS_OF(config->tracepoint) == cTracePoint) {
       rb_tracepoint_disable(config->tracepoint);
     }
-    config->state = RS_OPEN;
+    config->tracing = false;
   }
 }
 
@@ -186,7 +102,7 @@ static void event_hook(VALUE tpval, void *data) {
   if (config->tid != gettid()) return;
   if (in_fork(config)) {
     rb_tracepoint_disable(config->tracepoint);
-    config->state = RS_OPEN;
+    config->tracing = false;
     return;
   }
 
@@ -205,32 +121,25 @@ static void event_hook(VALUE tpval, void *data) {
     return;
   }
 
-  rs_callsite_t trace_path = tracearg_path(trace_arg);
-  bool blacklisted = rejected_path(trace_path.filepath, config);
-
-  rs_tracepoint_t trace = extract_full_tracevals(trace_arg, &trace_path);
+  config->callsite = tracearg_path(trace_arg);
 
-  rs_stack_push(&config->stack, trace, blacklisted);
+  config->caller = rs_stack_peek(&config->stack);
 
-  if (blacklisted) return;
+  rs_method_desc_t method_desc = called_method_desc(trace_arg);
+  rs_stack_push(&config->stack, (rs_stack_frame_t){.method = method_desc});
 
-  rs_stack_frame_t *stack_frame = rs_stack_peek(&config->stack);
-  rs_stack_frame_t *caller_frame = rs_stack_below(&config->stack, stack_frame);
-  log_trace_event_with_caller(config->output_buffer, config->log, stack_frame,
-                              caller_frame);
+  rb_funcall(config->trace_proc, id_call, 1, config->self);
 }
 
 static void rs_gc_mark(Rotoscope *config) {
-  rb_gc_mark(config->log);
   rb_gc_mark(config->tracepoint);
-  rb_gc_mark(config->output_buffer);
+  rb_gc_mark(config->trace_proc);
   rs_stack_mark(&config->stack);
 }
 
 void rs_dealloc(Rotoscope *config) {
   stop_tracing_on_cleanup(config);
   rs_stack_free(&config->stack);
-  xfree(config->blacklist);
   xfree(config);
 }
 
@@ -239,12 +148,16 @@ static VALUE rs_alloc(VALUE klass) {
   VALUE self =
       Data_Make_Struct(klass, Rotoscope, rs_gc_mark, rs_dealloc, config);
   config->self = self;
-  config->log = Qnil;
-  config->tracepoint = rb_tracepoint_new(Qnil, EVENT_CALL | EVENT_RETURN,
-                                         event_hook, (void *)config);
   config->pid = getpid();
   config->tid = gettid();
-  config->output_buffer = Qnil;
+  config->tracing = false;
+  config->caller = NULL;
+  config->callsite.filepath = Qnil;
+  config->callsite.lineno = 0;
+  config->trace_proc = Qnil;
+  rs_stack_init(&config->stack, STACK_CAPACITY);
+  config->tracepoint = rb_tracepoint_new(Qnil, EVENT_CALL | EVENT_RETURN,
+                                         event_hook, (void *)config);
   return self;
 }
 
@@ -254,133 +167,154 @@ static Rotoscope *get_config(VALUE self) {
   return config;
 }
 
-void copy_blacklist(Rotoscope *config, VALUE blacklist) {
-  Check_Type(blacklist, T_ARRAY);
+VALUE rotoscope_initialize(VALUE self) {
+  Rotoscope *config = get_config(self);
+  config->trace_proc = rb_block_proc();
+  return self;
+}
 
-  size_t blacklist_malloc_size =
-      RARRAY_LEN(blacklist) * sizeof(*config->blacklist);
+VALUE rotoscope_start_trace(VALUE self) {
+  Rotoscope *config = get_config(self);
+  rb_tracepoint_enable(config->tracepoint);
+  config->tracing = true;
+  return Qnil;
+}
 
-  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;
+VALUE rotoscope_stop_trace(VALUE self) {
+  Rotoscope *config = get_config(self);
+  if (rb_tracepoint_enabled_p(config->tracepoint)) {
+    rb_tracepoint_disable(config->tracepoint);
+    config->tracing = false;
+    rs_stack_reset(&config->stack);
   }
 
-  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++;
-  }
+  return Qnil;
 }
 
-VALUE initialize(int argc, VALUE *argv, VALUE self) {
+VALUE rotoscope_tracing_p(VALUE self) {
   Rotoscope *config = get_config(self);
-  VALUE output, blacklist;
+  return config->tracing ? Qtrue : Qfalse;
+}
 
-  rb_scan_args(argc, argv, "11", &output, &blacklist);
+VALUE rotoscope_receiver(VALUE self) {
+  Rotoscope *config = get_config(self);
+  return rb_tracearg_self(rb_tracearg_from_tracepoint(config->tracepoint));
+}
 
-  if (!NIL_P(blacklist)) {
-    copy_blacklist(config, blacklist);
+VALUE rotoscope_receiver_class(VALUE self) {
+  Rotoscope *config = get_config(self);
+  rs_stack_frame_t *call = rs_stack_peek(&config->stack);
+  if (call == NULL) {
+    return Qnil;
   }
+  return rs_method_class(&call->method);
+}
 
-  config->log = output;
+VALUE rotoscope_receiver_class_name(VALUE self) {
+  VALUE klass = rotoscope_receiver_class(self);
+  if (klass == Qnil) {
+    return Qnil;
+  }
+  return class2str(klass);
+}
 
-  rb_io_write(config->log, str_header);
+VALUE rotoscope_method_name(VALUE self) {
+  Rotoscope *config = get_config(self);
+  rs_stack_frame_t *call = rs_stack_peek(&config->stack);
+  if (call == NULL) {
+    return Qnil;
+  }
+  return rb_sym2str(call->method.id);
+}
 
-  rs_stack_init(&config->stack, STACK_CAPACITY);
-  config->state = RS_OPEN;
-  config->output_buffer = rb_str_buf_new(LOG_BUFFER_SIZE);
-  return self;
+VALUE rotoscope_singleton_method_p(VALUE self) {
+  Rotoscope *config = get_config(self);
+  rs_stack_frame_t *call = rs_stack_peek(&config->stack);
+  if (call == NULL) {
+    return Qnil;
+  }
+  return call->method.singleton_p ? Qtrue : Qfalse;
 }
 
-VALUE rotoscope_start_trace(VALUE self) {
+VALUE rotoscope_caller_object(VALUE self) {
   Rotoscope *config = get_config(self);
-  rb_tracepoint_enable(config->tracepoint);
-  config->state = RS_TRACING;
-  return Qnil;
+  if (config->caller == NULL) {
+    return Qnil;
+  }
+  return config->caller->method.receiver;
 }
 
-VALUE rotoscope_stop_trace(VALUE self) {
+VALUE rotoscope_caller_class(VALUE self) {
   Rotoscope *config = get_config(self);
-  if (rb_tracepoint_enabled_p(config->tracepoint)) {
-    rb_tracepoint_disable(config->tracepoint);
-    config->state = RS_OPEN;
-    rs_stack_reset(&config->stack);
+  if (config->caller == NULL) {
+    return Qnil;
   }
+  return rs_method_class(&config->caller->method);
+}
 
-  return Qnil;
+VALUE rotoscope_caller_class_name(VALUE self) {
+  VALUE klass = rotoscope_caller_class(self);
+  if (klass == Qnil) {
+    return Qnil;
+  }
+  return class2str(klass);
 }
 
-VALUE rotoscope_close(VALUE self) {
+VALUE rotoscope_caller_method_name(VALUE self) {
   Rotoscope *config = get_config(self);
-  if (config->state == RS_CLOSED) {
-    return Qtrue;
+  if (config->caller == NULL) {
+    return Qnil;
   }
-  rb_tracepoint_disable(config->tracepoint);
-  config->state = RS_OPEN;
-  if (!in_fork(config)) {
-    rb_funcall(config->log, id_close, 0);
-  }
-  config->state = RS_CLOSED;
-  return Qtrue;
+  return rb_sym2str(config->caller->method.id);
 }
 
-VALUE rotoscope_io(VALUE self) {
+VALUE rotoscope_caller_singleton_method_p(VALUE self) {
   Rotoscope *config = get_config(self);
-  return config->log;
+  if (config->caller == NULL) {
+    return Qnil;
+  }
+  return config->caller->method.singleton_p ? Qtrue : Qfalse;
 }
 
-VALUE rotoscope_trace(VALUE self) {
-  rotoscope_start_trace(self);
-  return rb_ensure(rb_yield, Qundef, rotoscope_stop_trace, self);
+VALUE rotoscope_caller_path(VALUE self) {
+  Rotoscope *config = get_config(self);
+  return config->callsite.filepath;
 }
 
-VALUE rotoscope_state(VALUE self) {
+VALUE rotoscope_caller_lineno(VALUE self) {
   Rotoscope *config = get_config(self);
-  switch (config->state) {
-    case RS_OPEN:
-      return ID2SYM(rb_intern("open"));
-    case RS_TRACING:
-      return ID2SYM(rb_intern("tracing"));
-    default:
-      return ID2SYM(rb_intern("closed"));
-  }
+  return UINT2NUM(config->callsite.lineno);
 }
 
 void Init_rotoscope(void) {
   cTracePoint = rb_const_get(rb_cObject, rb_intern("TracePoint"));
 
   id_initialize = rb_intern("initialize");
-  id_gsub = rb_intern("gsub");
-  id_close = rb_intern("close");
-
-  str_quote = rb_str_new_literal("\"");
-  rb_global_variable(&str_quote);
-  str_escaped_quote = rb_str_new_literal("\"\"");
-  rb_global_variable(&str_escaped_quote);
-
-  str_header = rb_str_new_literal(RS_CSV_HEADER "\n");
-  rb_global_variable(&str_header);
+  id_call = rb_intern("call");
 
   cRotoscope = rb_define_class("Rotoscope", rb_cObject);
   rb_define_alloc_func(cRotoscope, rs_alloc);
-  rb_define_method(cRotoscope, "initialize", initialize, -1);
-  rb_define_method(cRotoscope, "trace", (VALUE(*)(ANYARGS))rotoscope_trace, 0);
-  rb_define_method(cRotoscope, "close", (VALUE(*)(ANYARGS))rotoscope_close, 0);
-  rb_define_method(cRotoscope, "io", rotoscope_io, 0);
-  rb_define_method(cRotoscope, "start_trace",
-                   (VALUE(*)(ANYARGS))rotoscope_start_trace, 0);
-  rb_define_method(cRotoscope, "stop_trace",
-                   (VALUE(*)(ANYARGS))rotoscope_stop_trace, 0);
-  rb_define_method(cRotoscope, "state", (VALUE(*)(ANYARGS))rotoscope_state, 0);
+  rb_define_method(cRotoscope, "initialize", rotoscope_initialize, 0);
+  rb_define_method(cRotoscope, "start_trace", rotoscope_start_trace, 0);
+  rb_define_method(cRotoscope, "stop_trace", rotoscope_stop_trace, 0);
+  rb_define_method(cRotoscope, "tracing?", rotoscope_tracing_p, 0);
+  rb_define_method(cRotoscope, "receiver", rotoscope_receiver, 0);
+  rb_define_method(cRotoscope, "receiver_class", rotoscope_receiver_class, 0);
+  rb_define_method(cRotoscope, "receiver_class_name",
+                   rotoscope_receiver_class_name, 0);
+  rb_define_method(cRotoscope, "method_name", rotoscope_method_name, 0);
+  rb_define_method(cRotoscope, "singleton_method?",
+                   rotoscope_singleton_method_p, 0);
+  rb_define_method(cRotoscope, "caller_object", rotoscope_caller_object, 0);
+  rb_define_method(cRotoscope, "caller_class", rotoscope_caller_class, 0);
+  rb_define_method(cRotoscope, "caller_class_name", rotoscope_caller_class_name,
+                   0);
+  rb_define_method(cRotoscope, "caller_method_name",
+                   rotoscope_caller_method_name, 0);
+  rb_define_method(cRotoscope, "caller_singleton_method?",
+                   rotoscope_caller_singleton_method_p, 0);
+  rb_define_method(cRotoscope, "caller_path", rotoscope_caller_path, 0);
+  rb_define_method(cRotoscope, "caller_lineno", rotoscope_caller_lineno, 0);
 
   init_callsite();
 }

data/ext/rotoscope/rotoscope.h

@@ -7,51 +7,18 @@
 #define EVENT_CALL (RUBY_EVENT_CALL | RUBY_EVENT_C_CALL)
 #define EVENT_RETURN (RUBY_EVENT_RETURN | RUBY_EVENT_C_RETURN)
 
-#define CLASS_METHOD "class"
-#define INSTANCE_METHOD "instance"
-
 #define STACK_CAPACITY 500
-#define LOG_BUFFER_SIZE 1000
-
-// clang-format off
-
-#define RS_CSV_HEADER \
-  "entity,caller_entity,filepath,lineno,method_name,method_level,caller_method_name,caller_method_level"
-#define RS_CSV_FORMAT "\"%s\",\"%s\",\"%s\",%d,\"%s\",%s,\"%s\",%s"
-#define RS_CSV_VALUES(trace, caller_trace, method_name, caller_method_name) \
-  StringValueCStr((trace)->entity),        \
-  StringValueCStr((caller_trace)->entity), \
-  StringValueCStr((trace)->filepath),      \
-  (trace)->lineno,                         \
-  StringValueCStr(method_name),            \
-  (trace)->method_level,                   \
-  StringValueCStr(caller_method_name),     \
-  (caller_trace)->method_level
-
-// clang-format on
-
-typedef enum {
-  RS_CLOSED = 0,
-  RS_OPEN,
-  RS_TRACING,
-} rs_state;
 
 typedef struct {
   VALUE self;
-  VALUE log;
   VALUE tracepoint;
-  const char **blacklist;
-  unsigned long blacklist_size;
   pid_t pid;
   unsigned long tid;
-  rs_state state;
+  bool tracing;
   rs_stack_t stack;
-  VALUE output_buffer;
+  rs_stack_frame_t *caller;
+  rs_callsite_t callsite;
+  VALUE trace_proc;
 } Rotoscope;
 
-typedef struct {
-  VALUE name;
-  const char *method_level;
-} rs_class_desc_t;
-
 #endif

data/ext/rotoscope/stack.c

@@ -3,19 +3,6 @@
 #include <stdlib.h>
 #include <string.h>
 #include "ruby.h"
-#include "tracepoint.h"
-
-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,
-                        .entity = rb_str_new_cstr("<ROOT>"),
-                        .filepath = rb_unknown_str,
-                        .method_name = rb_unknown_str,
-                        .method_level = UNKNOWN_STR,
-                        .lineno = 0};
-  rs_stack_push(stack, root_trace, false);
-}
 
 static void resize_buffer(rs_stack_t *stack) {
   unsigned int newsize = stack->capacity * 2;
@@ -31,17 +18,12 @@ 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,
-                               bool blacklisted) {
+void rs_stack_push(rs_stack_t *stack, rs_stack_frame_t new_frame) {
   if (rs_stack_full(stack)) {
     resize_buffer(stack);
   }
 
-  rs_stack_frame_t new_frame =
-      (rs_stack_frame_t){.tp = trace, .blacklisted = blacklisted};
-
   stack->contents[++stack->top] = new_frame;
-  return new_frame;
 }
 
 rs_stack_frame_t rs_stack_pop(rs_stack_t *stack) {
@@ -55,29 +37,13 @@ rs_stack_frame_t rs_stack_pop(rs_stack_t *stack) {
 
 rs_stack_frame_t *rs_stack_peek(rs_stack_t *stack) {
   if (rs_stack_empty(stack)) {
-    fprintf(stderr, "Stack is empty!\n");
-    exit(1);
+    return NULL;
   }
 
   return &stack->contents[stack->top];
 }
 
-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);
-}
+void rs_stack_reset(rs_stack_t *stack) { stack->top = -1; }
 
 void rs_stack_free(rs_stack_t *stack) {
   xfree(stack->contents);
@@ -91,13 +57,11 @@ void rs_stack_init(rs_stack_t *stack, unsigned int capacity) {
   stack->contents = contents;
   stack->capacity = capacity;
   stack->top = -1;
-
-  insert_root_node(stack);
 }
 
 void rs_stack_mark(rs_stack_t *stack) {
   for (int i = 0; i <= stack->top; i++) {
-    rs_stack_frame_t frame = stack->contents[i];
-    rs_tracepoint_mark(&frame.tp);
+    rs_stack_frame_t *frame = &stack->contents[i];
+    rs_method_desc_mark(&frame->method);
   }
 }

data/ext/rotoscope/stack.h

@@ -1,14 +1,9 @@
 #ifndef _INC_ROTOSCOPE_STACK_H_
 #define _INC_ROTOSCOPE_STACK_H_
 #include <stdbool.h>
-#include "tracepoint.h"
+#include "method_desc.h"
 
-#define UNKNOWN_STR "<UNKNOWN>"
-
-typedef struct rs_stack_frame_t {
-  struct rs_tracepoint_t tp;
-  bool blacklisted;
-} rs_stack_frame_t;
+typedef struct { rs_method_desc_t method; } rs_stack_frame_t;
 
 typedef struct {
   int capacity;
@@ -19,12 +14,11 @@ typedef struct {
 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);
+void rs_stack_push(rs_stack_t *stack, rs_stack_frame_t frame);
 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

@@ -1,70 +1,13 @@
 # frozen_string_literal: true
 require 'rotoscope/rotoscope'
-require 'csv'
 
 class Rotoscope
-  class << self
-    def new(output, blacklist: [])
-      if output.is_a?(String)
-        io = File.open(output, 'w')
-        prevent_flush_from_finalizer_in_fork(io)
-        obj = super(io, blacklist)
-        obj.log_path = output
-        obj
-      else
-        super(output, blacklist)
-      end
-    end
+  autoload :CallLogger, 'rotoscope/call_logger'
 
-    def trace(dest, blacklist: [])
-      rs = new(dest, blacklist: blacklist)
-      rs.trace { yield rs }
-      rs
-    ensure
-      rs.close if rs && dest.is_a?(String)
-    end
-
-    private
-
-    def prevent_flush_from_finalizer_in_fork(io)
-      pid = Process.pid
-      finalizer = lambda do |_|
-        next if Process.pid == pid
-        # close the file descriptor from another IO object so
-        # buffered writes aren't flushed
-        IO.for_fd(io.fileno).close
-      end
-      ObjectSpace.define_finalizer(io, finalizer)
-    end
-  end
-
-  attr_accessor :log_path
-
-  def mark(message = "")
-    state = self.state
-    if state == :tracing
-      # stop tracing to avoid logging these io method calls
-      stop_trace
-    end
-    io.write("--- ")
-    io.puts(message)
+  def trace
+    start_trace
+    yield
   ensure
-    start_trace if state == :tracing
-  end
-
-  def closed?
-    state == :closed
-  end
-
-  def inspect
-    "Rotoscope(state: #{state}, log_path: \"#{short_log_path}\", object_id: #{format('0x00%x', object_id << 1)})"
-  end
-
-  private
-
-  def short_log_path
-    return log_path if log_path.length < 40
-    chars = log_path.chars
-    "#{chars.first(17).join('')}...#{chars.last(20).join('')}"
+    stop_trace
   end
 end

data/lib/rotoscope/call_logger.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+require 'csv'
+
+class Rotoscope
+  class CallLogger
+    class << self
+      def trace(dest, blacklist: [])
+        rs = new(dest, blacklist: blacklist)
+        rs.trace { yield rs }
+        rs
+      ensure
+        rs.io.close if rs && dest.is_a?(String)
+      end
+    end
+
+    HEADER = "entity,caller_entity,filepath,lineno,method_name,method_level,caller_method_name,caller_method_level\n"
+
+    attr_reader :io, :blacklist
+
+    def initialize(output = nil, blacklist: nil)
+      unless blacklist.is_a?(Regexp)
+        blacklist = Regexp.union(blacklist || [])
+      end
+      @blacklist = blacklist
+
+      if output.is_a?(String)
+        @io = File.open(output, 'w')
+        prevent_flush_from_finalizer_in_fork(@io)
+      else
+        @io = output
+      end
+      @output_buffer = ''.dup
+      @pid = Process.pid
+      @thread = Thread.current
+
+      @io << HEADER
+
+      @rotoscope = Rotoscope.new(&method(:log_call))
+    end
+
+    def trace
+      start_trace
+      yield
+    ensure
+      @rotoscope.stop_trace
+    end
+
+    def start_trace
+      @rotoscope.start_trace
+    end
+
+    def stop_trace
+      @rotoscope.stop_trace
+    end
+
+    def mark(message = "")
+      was_tracing = @rotoscope.tracing?
+      if was_tracing
+        # stop tracing to avoid logging these io method calls
+        @rotoscope.stop_trace
+      end
+      if @pid == Process.pid && @thread == Thread.current
+        @io.write("--- ")
+        @io.puts(message)
+      end
+    ensure
+      @rotoscope.start_trace if was_tracing
+    end
+
+    def close
+      @rotoscope.stop_trace
+      if @pid == Process.pid && @thread == Thread.current
+        @io.close
+      end
+      true
+    end
+
+    def closed?
+      @io.closed?
+    end
+
+    def state
+      return :closed if io.closed?
+      @rotoscope.tracing? ? :tracing : :open
+    end
+
+    private
+
+    def log_call(call)
+      return if blacklist.match?(call.caller_path)
+      return if self == call.receiver
+
+      if call.caller_method_name.nil?
+        caller_class_name = '<ROOT>'
+        caller_method_name = '<UNKNOWN>'
+        caller_method_level = '<UNKNOWN>'
+      else
+        caller_class_name = call.caller_class_name
+        caller_method_name = escape_csv_string(call.caller_method_name)
+        caller_method_level = call.caller_singleton_method? ? 'class' : 'instance'
+      end
+
+      call_method_level = call.singleton_method? ? 'class' : 'instance'
+      method_name = escape_csv_string(call.method_name)
+
+      buffer = @output_buffer
+      buffer.clear
+      buffer <<
+        '"' << call.receiver_class_name << '",' \
+        '"' << caller_class_name << '",' \
+        '"' << call.caller_path << '",' \
+        << call.caller_lineno.to_s << ',' \
+        '"' << method_name << '",' \
+        << call_method_level << ',' \
+        '"' << caller_method_name << '",' \
+        << caller_method_level << "\n"
+      io.write(buffer)
+    end
+
+    def escape_csv_string(string)
+      string.include?('"') ? string.gsub('"', '""') : string
+    end
+
+    def prevent_flush_from_finalizer_in_fork(io)
+      pid = Process.pid
+      finalizer = lambda do |_|
+        next if Process.pid == pid
+        # close the file descriptor from another IO object so
+        # buffered writes aren't flushed
+        IO.for_fd(io.fileno).close
+      end
+      ObjectSpace.define_finalizer(io, finalizer)
+    end
+  end
+end

data/lib/rotoscope/version.rb

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

data/rotoscope.gemspec

@@ -25,5 +25,5 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'rake-compiler', '~> 0.9'
   s.add_development_dependency 'mocha', '~> 0.14'
   s.add_development_dependency 'minitest', '~> 5.0'
-  s.add_development_dependency 'rubocop', '~> 0.49'
+  s.add_development_dependency 'rubocop', '~> 0.56'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rotoscope
 version: !ruby/object:Gem::Version
-  version: 0.3.0.pre.7
+  version: 0.3.0.pre.8
 platform: ruby
 authors:
 - Jahfer Husain
@@ -59,14 +59,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.49'
+        version: '0.56'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.49'
+        version: '0.56'
 description: High-performance logger of Ruby method invocations
 email: jahfer.husain@shopify.com
 executables: []
@@ -88,13 +88,14 @@ files:
 - ext/rotoscope/callsite.c
 - ext/rotoscope/callsite.h
 - ext/rotoscope/extconf.rb
+- ext/rotoscope/method_desc.c
+- ext/rotoscope/method_desc.h
 - ext/rotoscope/rotoscope.c
 - ext/rotoscope/rotoscope.h
 - ext/rotoscope/stack.c
 - ext/rotoscope/stack.h
-- ext/rotoscope/tracepoint.c
-- ext/rotoscope/tracepoint.h
 - lib/rotoscope.rb
+- lib/rotoscope/call_logger.rb
 - lib/rotoscope/version.rb
 - rotoscope.gemspec
 homepage: https://github.com/shopify/rotoscope

data/ext/rotoscope/tracepoint.c

@@ -1,8 +0,0 @@
-#include "tracepoint.h"
-#include "ruby.h"
-
-void rs_tracepoint_mark(rs_tracepoint_t *tracepoint) {
-  rb_gc_mark(tracepoint->entity);
-  rb_gc_mark(tracepoint->filepath);
-  rb_gc_mark(tracepoint->method_name);
-}

data/ext/rotoscope/tracepoint.h

@@ -1,17 +0,0 @@
-#ifndef _INC_ROTOSCOPE_TRACEPOINT_H_
-#define _INC_ROTOSCOPE_TRACEPOINT_H_
-
-#include "ruby.h"
-
-typedef struct rs_tracepoint_t {
-  const char *event;
-  VALUE entity;
-  VALUE filepath;
-  VALUE method_name;
-  const char *method_level;
-  unsigned int lineno;
-} rs_tracepoint_t;
-
-void rs_tracepoint_mark(rs_tracepoint_t *tracepoint);
-
-#endif