rotoscope 0.2.2 → 0.3.0.pre.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4d1b991a9d63ea46762db53c24178d30ec63e361
-  data.tar.gz: c3e44a17741d2b5e5bb90a490ac2c98d6dd87889
+  metadata.gz: 8a94009a6d6ee2a34d124e8b922feb3ff3eda7f2
+  data.tar.gz: eab31fe889c50ea034197aa1a435ccb22c832630
 SHA512:
-  metadata.gz: be48429248b53ca6a9a9a1cf5cce8b130cb799419e557fe2da757b828a08ccfda64ecbc920109c40d301304b0d24a2811fd742f4f635160bd96b9c4b01b31121
-  data.tar.gz: aee5f638d65fc3d167f5f5f6d2a5097866fffc11612f312809bebc3ad484928b36f135793c41e4948daae0b2f4b5208104edb25dcba0224affa2bc8758ec91ad
+  metadata.gz: 8ab381c724461c0b5dbab3a8dbbbf3e451c5aae060b8aecbaa9f28abc4d7aa636ecf7cd451b68537e104e13fc53c45243c47e4b44b48875f58bf1e32902a3f58
+  data.tar.gz: 5a598811ac79f0524d0e2d93d28a727a51e296cb575ed1de9b98e0f1b3921927b8557873e0bdcc682b8f7d09136f6d347c5d6eb2f8a7192bf39355a01e26f228

data/ext/rotoscope/rotoscope.c

@@ -14,9 +14,7 @@
 #include "tracepoint.h"
 
 VALUE cRotoscope, cTracePoint;
-
-// recursive with singleton2str
-static rs_class_desc_t class2str(VALUE klass);
+ID id_initialize;
 
 static unsigned long gettid() {
   return NUM2ULONG(rb_obj_id(rb_thread_current()));
@@ -47,46 +45,27 @@ static bool rejected_path(VALUE path, Rotoscope *config) {
   return false;
 }
 
-static VALUE class_of_singleton(VALUE klass) {
-  return rb_iv_get(klass, "__attached__");
-}
-
-static bool is_class_singleton(VALUE klass) {
-  VALUE obj = class_of_singleton(klass);
-  return (RB_TYPE_P(obj, T_MODULE) || RB_TYPE_P(obj, T_CLASS));
-}
-
-static VALUE singleton2str(VALUE klass) {
-  if (is_class_singleton(klass)) {
-    VALUE obj = class_of_singleton(klass);
-    VALUE cached_lookup = rb_class_path_cached(obj);
-    VALUE name = (NIL_P(cached_lookup)) ? rb_class_name(obj) : cached_lookup;
-    return name;
-  } else  // singleton of an instance
-  {
-    return singleton2str(CLASS_OF(klass));
+static VALUE class_path(VALUE klass) {
+  VALUE cached_path = rb_class_path_cached(klass);
+  if (!NIL_P(cached_path)) {
+    return cached_path;
   }
+  return rb_class_path(klass);
 }
 
-static rs_class_desc_t class2str(VALUE klass) {
-  rs_class_desc_t real_class;
-  real_class.method_level = INSTANCE_METHOD;
+static VALUE singleton_object(VALUE singleton_class) {
+  return rb_iv_get(singleton_class, "__attached__");
+}
 
-  VALUE cached_lookup = rb_class_path_cached(klass);
-  if (RTEST(cached_lookup)) {
-    real_class.name = cached_lookup;
-  } else {
-    if (FL_TEST(klass, FL_SINGLETON)) {
-      real_class.name = singleton2str(klass);
-      if (is_class_singleton(klass)) {
-        real_class.method_level = CLASS_METHOD;
-      }
-    } else {
-      real_class.name = rb_class_path(klass);
+static VALUE class2str(VALUE klass) {
+  while (FL_TEST(klass, FL_SINGLETON)) {
+    klass = singleton_object(klass);
+    if (!RB_TYPE_P(klass, T_MODULE) && !RB_TYPE_P(klass, T_CLASS)) {
+      // singleton of an instance
+      klass = rb_obj_class(klass);
     }
   }
-
-  return real_class;
+  return class_path(klass);
 }
 
 static rs_callsite_t tracearg_path(rb_trace_arg_t *trace_arg) {
@@ -101,19 +80,21 @@ 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_MODULE) || RB_TYPE_P(self, T_OBJECT)) {
-    klass = CLASS_OF(self);
-  } else if (RB_TYPE_P(self, T_CLASS)) {
-    // Does the object have an attached singleton?
-    // If not, name based on self instead of its singleton
-    klass = (FL_TEST(CLASS_OF(self), FL_SINGLETON)) ? CLASS_OF(self) : self;
+  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 {
-    klass = rb_tracearg_defined_class(trace_arg);
+    method_level = INSTANCE_METHOD;
+    klass = rb_obj_class(self);
   }
 
-  return class2str(klass);
+  return (rs_class_desc_t){
+      .name = class2str(klass), .method_level = method_level,
+  };
 }
 
 static VALUE tracearg_method_name(rb_trace_arg_t *trace_arg) {
@@ -138,30 +119,24 @@ static rs_tracepoint_t extract_full_tracevals(rb_trace_arg_t *trace_arg,
 
 static bool in_fork(Rotoscope *config) { return config->pid != getpid(); }
 
-static bool tracecmp(rs_tracepoint_t *a, rs_tracepoint_t *b) {
-  return (!rb_str_cmp(a->method_name, b->method_name) &&
-          !rb_str_cmp(a->entity, b->entity) &&
-          a->method_level == b->method_level);
-}
-
-static void log_raw_trace(FILE *stream, rs_tracepoint_t trace) {
+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[500];
-static void log_stack_frame(FILE *stream, rs_stack_t *stack,
-                            rs_strmemo_t **call_memo, rs_tracepoint_t trace,
-                            rb_event_flag_t event) {
-  if (event & EVENT_CALL) {
-    rs_stack_frame_t frame = rs_stack_push(stack, trace);
-    sprintf((char *)output_buffer, RS_FLATTENED_CSV_FORMAT "\n",
-            RS_FLATTENED_CSV_VALUES(frame));
-
-    if (rs_strmemo_uniq(call_memo, output_buffer)) {
-      fputs((char *)output_buffer, stream);
-    }
-  } else if (event & EVENT_RETURN) {
-    if (tracecmp(&trace, &rs_stack_peek(stack)->tp)) rs_stack_pop(stack);
+unsigned char output_buffer[LOG_BUFFER_SIZE];
+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;
+  }
+
+  snprintf((char *)output_buffer, LOG_BUFFER_SIZE, RS_FLATTENED_CSV_FORMAT "\n",
+           RS_FLATTENED_CSV_VALUES(&stack_frame->tp, &caller->tp));
+
+  if (rs_strmemo_uniq(call_memo, output_buffer)) {
+    fputs((char *)output_buffer, stream);
   }
 }
 
@@ -176,19 +151,40 @@ static void event_hook(VALUE tpval, void *data) {
   }
 
   rb_trace_arg_t *trace_arg = rb_tracearg_from_tracepoint(tpval);
-  rs_callsite_t trace_path = tracearg_path(trace_arg);
+  rb_event_flag_t event_flag = rb_tracearg_event_flag(trace_arg);
 
-  if (rejected_path(trace_path.filepath, config)) return;
+  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;
 
+  if (event_flag & EVENT_CALL) {
+    rs_stack_push(&config->stack, trace, blacklisted);
+  } else {
+    rs_stack_pop(&config->stack);
+  }
+
+  if (blacklisted) return;
+
   if (config->flatten_output) {
-    rb_event_flag_t event_flag = rb_tracearg_event_flag(trace_arg);
-    log_stack_frame(config->log, &config->stack, &config->call_memo, trace,
-                    event_flag);
+    if (event_flag & EVENT_CALL) {
+      log_trace_event_with_caller(config->log, rs_stack_peek(&config->stack),
+                                  &config->call_memo);
+    }
   } else {
-    log_raw_trace(config->log, trace);
+    log_trace_event(config->log, &trace);
   }
 }
 
@@ -317,6 +313,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, STACK_CAPACITY);
   }
 
   return Qnil;
@@ -373,6 +370,8 @@ VALUE rotoscope_state(VALUE self) {
 void Init_rotoscope(void) {
   cTracePoint = rb_const_get(rb_cObject, rb_intern("TracePoint"));
 
+  id_initialize = rb_intern("initialize");
+
   cRotoscope = rb_define_class("Rotoscope", rb_cObject);
   rb_define_alloc_func(cRotoscope, rs_alloc);
   rb_define_method(cRotoscope, "initialize", initialize, -1);

data/ext/rotoscope/rotoscope.h

@@ -12,29 +12,30 @@
 #define INSTANCE_METHOD "instance"
 
 #define STACK_CAPACITY 500
+#define LOG_BUFFER_SIZE 1000
 
 // clang-format off
 #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 {

data/ext/rotoscope/stack.c

@@ -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, false);
 }
 
 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;

data/ext/rotoscope/stack.h

@@ -7,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;
 
@@ -19,7 +20,7 @@ typedef struct {
 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_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/lib/rotoscope/version.rb

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

data/rotoscope.gemspec

@@ -1,10 +1,14 @@
 # frozen_string_literal: true
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "rotoscope/version"
+
 Gem::Specification.new do |s|
   s.name        = 'rotoscope'
-  s.version     = '0.2.2'
-  s.date        = '2017-09-16'
+  s.version     = Rotoscope::VERSION
+  s.date        = '2017-09-20'
 
-  s.authors     = ["Jahfer Husain"]
+  s.authors     = ["Jahfer Husain", "Dylan Thacker-Smith"]
   s.email       = 'jahfer.husain@shopify.com'
   s.homepage    = 'https://github.com/shopify/rotoscope'
   s.license     = 'MIT'
@@ -12,7 +16,9 @@ Gem::Specification.new do |s|
   s.summary     = "Tracing Ruby"
   s.description = "High-performance logger of Ruby method invocations"
 
-  s.files       = `git ls-files`.split("\n")
+  s.files       = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test)/})
+  end
   s.required_ruby_version = ">= 2.2.0"
   s.extensions = %w(ext/rotoscope/extconf.rb)
 

metadata

@@ -1,14 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: rotoscope
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.3.0.pre.1
 platform: ruby
 authors:
 - Jahfer Husain
+- Dylan Thacker-Smith
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-09-16 00:00:00.000000000 Z
+date: 2017-09-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -96,12 +97,9 @@ files:
 - ext/rotoscope/tracepoint.c
 - ext/rotoscope/tracepoint.h
 - lib/rotoscope.rb
+- lib/rotoscope/version.rb
 - lib/uthash/uthash.h
 - rotoscope.gemspec
-- test/fixture_inner.rb
-- test/fixture_outer.rb
-- test/monadify.rb
-- test/rotoscope_test.rb
 homepage: https://github.com/shopify/rotoscope
 licenses:
 - MIT
@@ -117,12 +115,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 2.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.10
+rubygems_version: 2.6.13
 signing_key: 
 specification_version: 4
 summary: Tracing Ruby

data/test/fixture_inner.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-class FixtureInner
-  def do_work
-    raise unless sum == 2
-  end
-
-  def sum
-    1 + 1
-  end
-end

data/test/fixture_outer.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-class FixtureOuter
-  def initialize
-    @inner = FixtureInner.new
-  end
-
-  def do_work
-    @inner.do_work
-  end
-end

data/test/monadify.rb

@@ -1,16 +0,0 @@
-module Monadify
-  define_method("contents") do
-    42
-  end
-
-  def foo
-    false
-  end
-
-  def monad(value)
-    foo
-    contents
-    define_singleton_method("contents=") { |val| val }
-    self.contents = value
-  end
-end

data/test/rotoscope_test.rb

@@ -1,482 +0,0 @@
-# frozen_string_literal: true
-$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
-$LOAD_PATH.unshift File.expand_path('../', __FILE__)
-require 'rotoscope'
-require 'minitest'
-require 'zlib'
-require 'fileutils'
-require 'csv'
-
-require 'fixture_inner'
-require 'fixture_outer'
-require 'monadify'
-
-module MyModule
-  def module_method; end
-end
-
-module PrependedModule
-  def prepended_method; end
-end
-
-class Example
-  prepend PrependedModule
-  include MyModule
-  extend MyModule
-  extend Monadify
-
-  class << self
-    def singleton_method
-      true
-    end
-
-    def apply(val)
-      monad val
-    end
-  end
-
-  def normal_method
-    true
-  end
-
-  def exception_method
-    oops
-  rescue
-    nil
-  end
-
-  def yielding_method
-    yield
-  end
-
-  private
-
-  def oops
-    raise "I've made a terrible mistake"
-  end
-end
-
-ROOT_FIXTURE_PATH = File.expand_path('../', __FILE__)
-INNER_FIXTURE_PATH = File.expand_path('../fixture_inner.rb', __FILE__)
-OUTER_FIXTURE_PATH = File.expand_path('../fixture_outer.rb', __FILE__)
-MONADIFY_PATH = File.expand_path('monadify.rb', ROOT_FIXTURE_PATH)
-
-class RotoscopeTest < MiniTest::Test
-  def setup
-    @logfile = File.expand_path('tmp/test.csv')
-  end
-
-  def teardown
-    FileUtils.remove_file(@logfile) if File.file?(@logfile)
-  end
-
-  def test_new
-    rs = Rotoscope.new(@logfile, blacklist: ['tmp'], flatten: true)
-    assert rs.is_a?(Rotoscope)
-  end
-
-  def test_close
-    rs = Rotoscope.new(@logfile)
-    assert rs.close
-  end
-
-  def test_closed?
-    rs = Rotoscope.new(@logfile)
-    refute_predicate rs, :closed?
-    rs.close
-    assert_predicate rs, :closed?
-  end
-
-  def test_state
-    rs = Rotoscope.new(@logfile)
-    assert_equal :open, rs.state
-    rs.trace do
-      assert_equal :tracing, rs.state
-    end
-    assert_equal :open, rs.state
-    rs.close
-    assert_equal :closed, rs.state
-  end
-
-  def test_mark
-    contents = rotoscope_trace do |rs|
-      Example.new.normal_method
-      rs.mark
-    end
-
-    assert_includes contents.split("\n"), '--- '
-  end
-
-  def test_mark_with_custom_strings
-    mark_strings = ["Hello", "ÅÉÎØÜ åéîøü"]
-    contents = rotoscope_trace do |rs|
-      e = Example.new
-      e.normal_method
-      mark_strings.each { |str| rs.mark(str) }
-    end
-
-    content_lines = contents.split("\n")
-    mark_strings.each do |str|
-      assert_includes content_lines, "--- #{str}"
-    end
-  end
-
-  def test_flatten
-    contents = rotoscope_trace(flatten: true) do
-      Example.new.normal_method
-    end
-
-    assert_equal [
-      { entity: "Example", method_name: "new", method_level: "class", filepath: "/rotoscope_test.rb", lineno: -1, caller_entity: "<ROOT>", caller_method_name: "<UNKNOWN>", caller_method_level: "<UNKNOWN>" },
-      { entity: "Example", method_name: "initialize", method_level: "instance", filepath: "/rotoscope_test.rb", lineno: -1, caller_entity: "Example", caller_method_name: "new", caller_method_level: "class" },
-      { entity: "Example", method_name: "normal_method", method_level: "instance", filepath: "/rotoscope_test.rb", lineno: -1, caller_entity: "<ROOT>", caller_method_name: "<UNKNOWN>", caller_method_level: "<UNKNOWN>" },
-    ], parse_and_normalize(contents)
-  end
-
-  def test_flatten_removes_duplicates
-    contents = rotoscope_trace(flatten: true) do
-      e = Example.new
-      10.times { e.normal_method }
-    end
-
-    assert_equal [
-      { entity: "Example", method_name: "new", method_level: "class", filepath: "/rotoscope_test.rb", lineno: -1, caller_entity: "<ROOT>", caller_method_name: "<UNKNOWN>", caller_method_level: "<UNKNOWN>" },
-      { entity: "Example", method_name: "initialize", method_level: "instance", filepath: "/rotoscope_test.rb", lineno: -1, caller_entity: "Example", caller_method_name: "new", caller_method_level: "class" },
-      { entity: "Integer", method_name: "times", method_level: "instance", filepath: "/rotoscope_test.rb", lineno: -1, caller_entity: "<ROOT>", caller_method_name: "<UNKNOWN>", caller_method_level: "<UNKNOWN>" },
-      { entity: "Example", method_name: "normal_method", method_level: "instance", filepath: "/rotoscope_test.rb", lineno: -1, caller_entity: "Integer", caller_method_name: "times", caller_method_level: "instance" },
-    ], parse_and_normalize(contents)
-  end
-
-  def test_start_trace_and_stop_trace
-    rs = Rotoscope.new(@logfile)
-    rs.start_trace
-    Example.new.normal_method
-    rs.stop_trace
-    rs.close
-    contents = File.read(@logfile)
-
-    assert_equal [
-      { event: "call", entity: "Example", method_name: "new", method_level: "class", filepath: "/rotoscope_test.rb", lineno: -1 },
-      { event: "call", entity: "Example", method_name: "initialize", method_level: "instance", filepath: "/rotoscope_test.rb", lineno: -1 },
-      { event: "return", entity: "Example", method_name: "initialize", method_level: "instance", filepath: "/rotoscope_test.rb", lineno: -1 },
-      { event: "return", entity: "Example", method_name: "new", method_level: "class", filepath: "/rotoscope_test.rb", lineno: -1 },
-      { event: "call", entity: "Example", method_name: "normal_method", method_level: "instance", filepath: "/rotoscope_test.rb", lineno: -1 },
-      { event: "return", entity: "Example", method_name: "normal_method", method_level: "instance", filepath: "/rotoscope_test.rb", lineno: -1 },
-    ], parse_and_normalize(contents)
-
-    assert_frames_consistent contents
-  end
-
-  def test_traces_instance_method
-    contents = rotoscope_trace { Example.new.normal_method }
-    assert_equal [
-      { event: "call", entity: "Example", method_name: "new", method_level: "class", filepath: "/rotoscope_test.rb", lineno: -1 },
-      { event: "call", entity: "Example", method_name: "initialize", method_level: "instance", filepath: "/rotoscope_test.rb", lineno: -1 },
-      { event: "return", entity: "Example", method_name: "initialize", method_level: "instance", filepath: "/rotoscope_test.rb", lineno: -1 },
-      { event: "return", entity: "Example", method_name: "new", method_level: "class", filepath: "/rotoscope_test.rb", lineno: -1 },
-      { event: "call", entity: "Example", method_name: "normal_method", method_level: "instance", filepath: "/rotoscope_test.rb", lineno: -1 },
-      { event: "return", entity: "Example", method_name: "normal_method", method_level: "instance", filepath: "/rotoscope_test.rb", lineno: -1 }
-    ], parse_and_normalize(contents)
-
-    assert_frames_consistent contents
-  end
-
-  def test_traces_yielding_method
-    contents = rotoscope_trace do
-      e = Example.new
-      e.yielding_method { e.normal_method }
-    end
-
-    assert_equal [
-      { event: "call", entity: "Example", method_name: "new", method_level: "class", filepath: "/rotoscope_test.rb", lineno: -1 },
-      { event: "call", entity: "Example", method_name: "initialize", method_level: "instance", filepath: "/rotoscope_test.rb", lineno: -1 },
-      { event: "return", entity: "Example", method_name: "initialize", method_level: "instance", filepath: "/rotoscope_test.rb", lineno: -1 },
-      { event: "return", entity: "Example", method_name: "new", method_level: "class", filepath: "/rotoscope_test.rb", lineno: -1 },
-      { event: "call", entity: "Example", method_name: "yielding_method", method_level: "instance", filepath: "/rotoscope_test.rb", lineno: -1 },
-      { event: "call", entity: "Example", method_name: "normal_method", method_level: "instance", filepath: "/rotoscope_test.rb", lineno: -1 },
-      { event: "return", entity: "Example", method_name: "normal_method", method_level: "instance", filepath: "/rotoscope_test.rb", lineno: -1 },
-      { event: "return", entity: "Example", method_name: "yielding_method", method_level: "instance", filepath: "/rotoscope_test.rb", lineno: -1 }
-    ], parse_and_normalize(contents)
-
-    assert_frames_consistent contents
-  end
-
-  def test_calls_are_consistent_after_exception
-    contents = rotoscope_trace { Example.new.exception_method }
-    assert_frames_consistent contents
-  end
-
-  def test_traces_and_formats_singletons_of_a_class
-    contents = rotoscope_trace { Example.singleton_method }
-    assert_equal [
-      { event: "call", entity: "Example", method_name: "singleton_method", method_level: "class", filepath: "/rotoscope_test.rb", lineno: -1 },
-      { event: "return", entity: "Example", method_name: "singleton_method", method_level: "class", filepath: "/rotoscope_test.rb", lineno: -1 }
-    ], parse_and_normalize(contents)
-
-    assert_frames_consistent contents
-  end
-
-  def test_traces_and_formats_singletons_of_an_instance
-    contents = rotoscope_trace { Example.new.singleton_class.singleton_method }
-    assert_equal [
-      { event: "call", entity: "Example", method_name: "new", method_level: "class", filepath: "/rotoscope_test.rb", lineno: -1 },
-      { event: "call", entity: "Example", method_name: "initialize", method_level: "instance", filepath: "/rotoscope_test.rb", lineno: -1 },
-      { event: "return", entity: "Example", method_name: "initialize", method_level: "instance", filepath: "/rotoscope_test.rb", lineno: -1 },
-      { event: "return", entity: "Example", method_name: "new", method_level: "class", filepath: "/rotoscope_test.rb", lineno: -1 },
-      { event: "call", entity: "Example", method_name: "singleton_class", method_level: "instance", filepath: "/rotoscope_test.rb", lineno: -1 },
-      { event: "return", entity: "Example", method_name: "singleton_class", method_level: "instance", filepath: "/rotoscope_test.rb", lineno: -1 },
-      { event: "call", entity: "Example", method_name: "singleton_method", method_level: "class", filepath: "/rotoscope_test.rb", lineno: -1 },
-      { event: "return", entity: "Example", method_name: "singleton_method", method_level: "class", filepath: "/rotoscope_test.rb", lineno: -1 },
-    ], parse_and_normalize(contents)
-
-    assert_frames_consistent contents
-  end
-
-  def test_traces_included_module_method
-    contents = rotoscope_trace { Example.new.module_method }
-    assert_equal [
-      { event: "call", entity: "Example", method_name: "new", method_level: "class", filepath: "/rotoscope_test.rb", lineno: -1 },
-      { event: "call", entity: "Example", method_name: "initialize", method_level: "instance", filepath: "/rotoscope_test.rb", lineno: -1 },
-      { event: "return", entity: "Example", method_name: "initialize", method_level: "instance", filepath: "/rotoscope_test.rb", lineno: -1 },
-      { event: "return", entity: "Example", method_name: "new", method_level: "class", filepath: "/rotoscope_test.rb", lineno: -1 },
-      { event: "call", entity: "Example", method_name: "module_method", method_level: "instance", filepath: "/rotoscope_test.rb", lineno: -1 },
-      { event: "return", entity: "Example", method_name: "module_method", method_level: "instance", filepath: "/rotoscope_test.rb", lineno: -1 }
-    ], parse_and_normalize(contents)
-
-    assert_frames_consistent contents
-  end
-
-  def test_traces_extended_module_method
-    contents = rotoscope_trace { Example.module_method }
-    assert_equal [
-      { event: "call", entity: "Example", method_name: "module_method", method_level: "class", filepath: "/rotoscope_test.rb", lineno: -1 },
-      { event: "return", entity: "Example", method_name: "module_method", method_level: "class", filepath: "/rotoscope_test.rb", lineno: -1 }
-    ], parse_and_normalize(contents)
-
-    assert_frames_consistent contents
-  end
-
-  def test_traces_prepended_module_method
-    contents = rotoscope_trace { Example.new.prepended_method }
-    assert_equal [
-      { event: "call", entity: "Example", method_name: "new", method_level: "class", filepath: "/rotoscope_test.rb", lineno: -1 },
-      { event: "call", entity: "Example", method_name: "initialize", method_level: "instance", filepath: "/rotoscope_test.rb", lineno: -1 },
-      { event: "return", entity: "Example", method_name: "initialize", method_level: "instance", filepath: "/rotoscope_test.rb", lineno: -1 },
-      { event: "return", entity: "Example", method_name: "new", method_level: "class", filepath: "/rotoscope_test.rb", lineno: -1 },
-      { event: "call", entity: "Example", method_name: "prepended_method", method_level: "instance", filepath: "/rotoscope_test.rb", lineno: -1 },
-      { event: "return", entity: "Example", method_name: "prepended_method", method_level: "instance", filepath: "/rotoscope_test.rb", lineno: -1 }
-    ], parse_and_normalize(contents)
-
-    assert_frames_consistent contents
-  end
-
-  def test_trace_ignores_calls_if_blacklisted
-    contents = rotoscope_trace(blacklist: [INNER_FIXTURE_PATH, OUTER_FIXTURE_PATH]) do
-      foo = FixtureOuter.new
-      foo.do_work
-    end
-
-    assert_equal [
-      { event: "call", entity: "FixtureOuter", method_name: "new", method_level: "class", filepath: "/rotoscope_test.rb", lineno: -1 },
-      { event: "call", entity: "FixtureOuter", method_name: "initialize", method_level: "instance", filepath: "/rotoscope_test.rb", lineno: -1 },
-      { event: "return", entity: "FixtureOuter", method_name: "initialize", method_level: "instance", filepath: "/rotoscope_test.rb", lineno: -1 },
-      { event: "return", entity: "FixtureOuter", method_name: "new", method_level: "class", filepath: "/rotoscope_test.rb", lineno: -1 },
-      { event: "call", entity: "FixtureOuter", method_name: "do_work", method_level: "instance", filepath: "/rotoscope_test.rb", lineno: -1 },
-      { event: "return", entity: "FixtureOuter", method_name: "do_work", method_level: "instance", filepath: "/rotoscope_test.rb", lineno: -1 },
-    ], parse_and_normalize(contents)
-
-    assert_frames_consistent contents
-  end
-
-  def test_trace_ignores_writes_in_fork
-    contents = rotoscope_trace do |rotoscope|
-      fork do
-        Example.singleton_method
-        rotoscope.mark
-        rotoscope.close
-      end
-      Example.singleton_method
-      Process.wait
-    end
-    assert_equal [
-      { event: "call", entity: "RotoscopeTest", method_name: "fork", method_level: "instance", filepath: "/rotoscope_test.rb", lineno: -1 },
-      { event: "return", entity: "RotoscopeTest", method_name: "fork", method_level: "instance", filepath: "/rotoscope_test.rb", lineno: -1 },
-      { event: "call", entity: "Example", method_name: "singleton_method", method_level: "class", filepath: "/rotoscope_test.rb", lineno: -1 },
-      { event: "return", entity: "Example", method_name: "singleton_method", method_level: "class", filepath: "/rotoscope_test.rb", lineno: -1 },
-      { event: "call", entity: "Process", method_name: "wait", method_level: "class", filepath: "/rotoscope_test.rb", lineno: -1 },
-      { event: "return", entity: "Process", method_name: "wait", method_level: "class", filepath: "/rotoscope_test.rb", lineno: -1 },
-    ], parse_and_normalize(contents)
-  end
-
-  def test_trace_disabled_on_close
-    contents = rotoscope_trace do |rotoscope|
-      Example.singleton_method
-      rotoscope.close
-      rotoscope.mark
-      Example.singleton_method
-    end
-    assert_equal [
-      { event: "call", entity: "Example", method_name: "singleton_method", method_level: "class", filepath: "/rotoscope_test.rb", lineno: -1 },
-      { event: "return", entity: "Example", method_name: "singleton_method", method_level: "class", filepath: "/rotoscope_test.rb", lineno: -1 },
-    ], parse_and_normalize(contents)
-  end
-
-  def test_trace_flatten
-    contents = rotoscope_trace(flatten: true) { Example.new.normal_method }
-    assert_equal [
-      { entity: "Example", method_name: "new", method_level: "class", filepath: "/rotoscope_test.rb", lineno: -1, caller_entity: "<ROOT>", caller_method_name: "<UNKNOWN>", caller_method_level: "<UNKNOWN>" },
-      { entity: "Example", method_name: "initialize", method_level: "instance", filepath: "/rotoscope_test.rb", lineno: -1, caller_entity: "Example", caller_method_name: "new", caller_method_level: "class" },
-      { entity: "Example", method_name: "normal_method", method_level: "instance", filepath: "/rotoscope_test.rb", lineno: -1, caller_entity: "<ROOT>", caller_method_name: "<UNKNOWN>", caller_method_level: "<UNKNOWN>" },
-    ], parse_and_normalize(contents)
-  end
-
-  def test_trace_flatten_across_files
-    contents = rotoscope_trace(flatten: true) do
-      foo = FixtureOuter.new
-      foo.do_work
-    end
-
-    assert_equal [
-      { entity: "FixtureOuter", method_name: "new", method_level: "class", filepath: "/rotoscope_test.rb", lineno: -1, caller_entity: "<ROOT>", caller_method_name: "<UNKNOWN>", caller_method_level: "<UNKNOWN>" },
-      { entity: "FixtureOuter", method_name: "initialize", method_level: "instance", filepath: "/rotoscope_test.rb", lineno: -1, caller_entity: "FixtureOuter", caller_method_name: "new", caller_method_level: "class" },
-      { entity: "FixtureInner", method_name: "new", method_level: "class", filepath: "/fixture_outer.rb", lineno: -1, caller_entity: "FixtureOuter", caller_method_name: "initialize", caller_method_level: "instance" },
-      { entity: "FixtureInner", method_name: "initialize", method_level: "instance", filepath: "/fixture_outer.rb", lineno: -1, caller_entity: "FixtureInner", caller_method_name: "new", caller_method_level: "class" },
-      { entity: "FixtureOuter", method_name: "do_work", method_level: "instance", filepath: "/rotoscope_test.rb", lineno: -1, caller_entity: "<ROOT>", caller_method_name: "<UNKNOWN>", caller_method_level: "<UNKNOWN>" },
-      { entity: "FixtureInner", method_name: "do_work", method_level: "instance", filepath: "/fixture_outer.rb", lineno: -1, caller_entity: "FixtureOuter", caller_method_name: "do_work", caller_method_level: "instance" },
-      { entity: "FixtureInner", method_name: "sum", method_level: "instance", filepath: "/fixture_inner.rb", lineno: -1, caller_entity: "FixtureInner", caller_method_name: "do_work", caller_method_level: "instance" }
-    ], parse_and_normalize(contents)
-  end
-
-  def test_trace_uses_io_objects
-    string_io = StringIO.new
-    Rotoscope.trace(string_io) do
-      Example.new.normal_method
-    end
-    refute_predicate string_io, :closed?
-    assert_predicate string_io, :eof?
-    contents = string_io.string
-
-    assert_equal [
-      { event: "call", entity: "Example", method_name: "new", method_level: "class", filepath: "/rotoscope_test.rb", lineno: -1 },
-      { event: "call", entity: "Example", method_name: "initialize", method_level: "instance", filepath: "/rotoscope_test.rb", lineno: -1 },
-      { event: "return", entity: "Example", method_name: "initialize", method_level: "instance", filepath: "/rotoscope_test.rb", lineno: -1 },
-      { event: "return", entity: "Example", method_name: "new", method_level: "class", filepath: "/rotoscope_test.rb", lineno: -1 },
-      { event: "call", entity: "Example", method_name: "normal_method", method_level: "instance", filepath: "/rotoscope_test.rb", lineno: -1 },
-      { event: "return", entity: "Example", method_name: "normal_method", method_level: "instance", filepath: "/rotoscope_test.rb", lineno: -1 },
-    ], parse_and_normalize(contents)
-
-    assert_frames_consistent contents
-  end
-
-  def test_stop_trace_before_start_does_not_raise
-    rs = Rotoscope.new(@logfile)
-    rs.stop_trace
-  end
-
-  def test_gc_rotoscope_without_stop_trace_does_not_crash
-    proc {
-      rs = Rotoscope.new(@logfile)
-      rs.start_trace
-    }.call
-    GC.start
-  end
-
-  def test_gc_rotoscope_without_stop_trace_does_not_break_process_cleanup
-    child_pid = fork do
-      rs = Rotoscope.new(@logfile)
-      rs.start_trace
-    end
-    Process.waitpid(child_pid)
-    assert_equal true, $CHILD_STATUS.success?
-  end
-
-  def test_log_path
-    rs = Rotoscope.new(File.expand_path('tmp/test.csv.gz'))
-    GC.start
-    assert_equal File.expand_path('tmp/test.csv.gz'), rs.log_path
-  end
-
-  def test_ignores_calls_inside_of_threads
-    thread = nil
-    contents = rotoscope_trace do
-      thread = Thread.new { Example.new }
-    end
-    thread.join
-
-    assert_equal [
-      { event: "call", entity: "Thread", method_name: "new", method_level: "class", filepath: "/rotoscope_test.rb", lineno: -1 },
-      { event: "call", entity: "Thread", method_name: "initialize", method_level: "instance", filepath: "/rotoscope_test.rb", lineno: -1 },
-      { event: "return", entity: "Thread", method_name: "initialize", method_level: "instance", filepath: "/rotoscope_test.rb", lineno: -1 },
-      { event: "return", entity: "Thread", method_name: "new", method_level: "class", filepath: "/rotoscope_test.rb", lineno: -1 },
-    ], parse_and_normalize(contents)
-  end
-
-  def test_dynamic_class_creation
-    contents = rotoscope_trace { Class.new }
-
-    assert_equal [
-      { event: "call", entity: "Class", method_name: "new", method_level: "class", filepath: "/rotoscope_test.rb", lineno: -1 },
-      { event: "call", entity: "#<Class:0xXXXXXX>", method_name: "initialize", method_level: "instance", filepath: "/rotoscope_test.rb", lineno: -1 },
-      { event: "call", entity: "Object", method_name: "inherited", method_level: "class", filepath: "/rotoscope_test.rb", lineno: -1 },
-      { event: "return", entity: "Object", method_name: "inherited", method_level: "class", filepath: "/rotoscope_test.rb", lineno: -1 },
-      { event: "return", entity: "#<Class:0xXXXXXX>", method_name: "initialize", method_level: "class", filepath: "/rotoscope_test.rb", lineno: -1 },
-      { event: "return", entity: "Class", method_name: "new", method_level: "class", filepath: "/rotoscope_test.rb", lineno: -1 }
-    ], parse_and_normalize(contents)
-  end
-
-  def test_dynamic_methods_in_blacklist
-    skip <<-FAILING_TEST_CASE
-      Return events for dynamically created methods (define_method, define_singleton_method)
-      do not have the correct stack frame information (the call of a dynamically defined method
-      is correctly treated as a Ruby :call, but its return must be treated as a :c_return)
-    FAILING_TEST_CASE
-
-    contents = rotoscope_trace(blacklist: [MONADIFY_PATH]) { Example.apply("my value!") }
-
-    assert_equal [
-      { event: "call", entity: "Example", method_name: "apply", method_level: "class", filepath: "/rotoscope_test.rb", lineno: -1 },
-      { event: "call", entity: "Example", method_name: "monad", method_level: "class", filepath: "/rotoscope_test.rb", lineno: -1 },
-      { event: "return", entity: "Example", method_name: "monad", method_level: "class", filepath: "/rotoscope_test.rb", lineno: -1 },
-      { event: "return", entity: "Example", method_name: "apply", method_level: "class", filepath: "/rotoscope_test.rb", lineno: -1 },
-    ], parse_and_normalize(contents)
-  end
-
-  def test_flatten_with_dynamic_methods_in_blacklist
-    # the failing test above passes when using `flatten: true` since unmatched stack returns are ignored
-    contents = rotoscope_trace(blacklist: [MONADIFY_PATH], flatten: true) { Example.apply("my value!") }
-
-    assert_equal [
-      { entity: "Example", method_name: "apply", method_level: "class", filepath: "/rotoscope_test.rb", lineno: -1, caller_entity: "<ROOT>", caller_method_name: "<UNKNOWN>", caller_method_level: "<UNKNOWN>" },
-      { entity: "Example", method_name: "monad", method_level: "class", filepath: "/rotoscope_test.rb", lineno: -1, caller_entity: "Example", caller_method_name: "apply", caller_method_level: "class" },
-    ], parse_and_normalize(contents)
-  end
-
-  private
-
-  def parse_and_normalize(csv_string)
-    CSV.parse(csv_string, headers: true, header_converters: :symbol).map do |row|
-      row = row.to_h
-      row[:lineno] = -1
-      row[:filepath] = row[:filepath].gsub(ROOT_FIXTURE_PATH, '')
-      row[:entity] = row[:entity].gsub(/:0x[a-fA-F0-9]{4,}/m, ":0xXXXXXX")
-      row
-    end
-  end
-
-  def assert_frames_consistent(csv_string)
-    assert_equal csv_string.scan(/\Acall/).size, csv_string.scan(/\Areturn/).size
-  end
-
-  def rotoscope_trace(blacklist: [], flatten: false)
-    Rotoscope.trace(@logfile, blacklist: blacklist, flatten: flatten) { |rotoscope| yield rotoscope }
-    File.read(@logfile)
-  end
-
-  def unzip(path)
-    File.open(path) { |f| Zlib::GzipReader.new(f).read }
-  end
-end
-
-# https://github.com/seattlerb/minitest/pull/683 needed to use
-# autorun without affecting the exit status of forked processes
-Minitest.run(ARGV)