rotoscope 0.3.0.pre.6 → 0.3.0.pre.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5e1efb6a5e9839ddf8219a7cfe6287195f0efbc5
-  data.tar.gz: 91bb41de1a6c892ccd9bb0f6e9b437c67fe90c68
+  metadata.gz: dc57c07b922488935b47e583d422a36d9fa32096
+  data.tar.gz: cd70207ab9f61bcd490506a5defc6c293dbec11d
 SHA512:
-  metadata.gz: 436314656fd8c5e6ebabfd3b89b3ad2951b7073f530b3ac1381c04ad0a972fe3e434595c8e0a07e0c13e6ef1c5f1177bcc270b5995a15538466a7c2553637a26
-  data.tar.gz: fae7fbf6c7c84b337579b1270f0620860dde11c0f88f8a526d2bfca87cf3eae8b2eee15de56c2ca3aca631538233bb351770f3c30cfda77fd0b4f1c3d73096d8
+  metadata.gz: 7c512251290df7ee37e72e0f130ca879da887f3ecdd206b60e9e4a361e422bf68daf6b6c42acbb1c20a40efaa4c7166334fc2e21d0df2e3dc1f9c722267b31c0
+  data.tar.gz: a5e1d3bdd7ae63147097154630aae6bb9c4153fa110be4fc1873cbce38f7d684a3e0f87cc1c80f4dfd811c04e21d21c8dcc5adad7de4afc91a977dc266ac0d41

data/ext/rotoscope/extconf.rb

@@ -4,7 +4,4 @@ require "mkmf"
 $CFLAGS << ' -std=c99 -Wall -Werror -Wno-declaration-after-statement'
 $defs << "-D_POSIX_SOURCE"
 
-uthash_path = File.expand_path('../../../lib/uthash', __FILE__)
-find_header('uthash.h', uthash_path) || raise
-
 create_makefile('rotoscope/rotoscope')

data/ext/rotoscope/rotoscope.c

@@ -2,6 +2,7 @@
 #include <ruby.h>
 #include <ruby/debug.h>
 #include <ruby/intern.h>
+#include <ruby/io.h>
 #include <ruby/version.h>
 #include <stdbool.h>
 #include <stdio.h>
@@ -10,21 +11,16 @@
 #include "callsite.h"
 #include "rotoscope.h"
 #include "stack.h"
-#include "strmemo.h"
 #include "tracepoint.h"
 
 VALUE cRotoscope, cTracePoint;
-ID id_initialize, id_gsub;
-VALUE str_quote, str_escaped_quote;
+ID id_initialize, id_gsub, id_close;
+VALUE str_quote, str_escaped_quote, str_header;
 
 static unsigned long gettid() {
   return NUM2ULONG(rb_obj_id(rb_thread_current()));
 }
 
-static int write_csv_header(FILE *log, const char *header) {
-  return fprintf(log, "%s\n", header);
-}
-
 static const char *evflag2name(rb_event_flag_t evflag) {
   switch (evflag) {
     case RUBY_EVENT_CALL:
@@ -120,6 +116,17 @@ static rs_tracepoint_t extract_full_tracevals(rb_trace_arg_t *trace_arg,
 
 static bool in_fork(Rotoscope *config) { return config->pid != getpid(); }
 
+// The GC sweep step will turn objects with finalizers (e.g. rs_dealloc)
+// to zombie objects until their finalizer is run. In this state, any
+// ruby objects in the Rotoscope struct may have already been collected
+// so they can't safely be used. If tracing isn't stopped before the
+// Rotoscope object has been garbage collected, then we still may receive
+// trace events for method calls in finalizers that run before the one
+// for the Rotoscope object.
+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;
@@ -127,36 +134,55 @@ VALUE escape_csv_string(VALUE string) {
   return rb_funcall(string, id_gsub, 2, str_quote, str_escaped_quote);
 }
 
-static void log_trace_event(FILE *stream, rs_tracepoint_t *trace) {
-  VALUE escaped_method_name = escape_csv_string(trace->method_name);
-  fprintf(stream, RS_CSV_FORMAT "\n",
-          RS_CSV_VALUES(trace, escaped_method_name));
-  RB_GC_GUARD(escaped_method_name);
-}
-
-unsigned char output_buffer[LOG_BUFFER_SIZE];
-static void log_trace_event_with_caller(FILE *stream,
+static void log_trace_event_with_caller(VALUE output_buffer, VALUE io,
                                         rs_stack_frame_t *stack_frame,
-                                        rs_stack_frame_t *caller_frame,
-                                        rs_strmemo_t **call_memo) {
+                                        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);
-  snprintf(
-      (char *)output_buffer, LOG_BUFFER_SIZE, RS_FLATTENED_CSV_FORMAT "\n",
-      RS_FLATTENED_CSV_VALUES(&stack_frame->tp, &caller_frame->tp,
-                              escaped_method_name, escaped_caller_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);
 
-  if (rs_strmemo_uniq(call_memo, output_buffer)) {
-    fputs((char *)output_buffer, stream);
+  rb_io_write(io, output_buffer);
+}
+
+static void stop_tracing_on_cleanup(Rotoscope *config) {
+  if (config->state == RS_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.
+    if (RB_TYPE_P(config->tracepoint, T_DATA) &&
+        CLASS_OF(config->tracepoint) == cTracePoint) {
+      rb_tracepoint_disable(config->tracepoint);
+    }
+    config->state = RS_OPEN;
   }
 }
 
 static void event_hook(VALUE tpval, void *data) {
   Rotoscope *config = (Rotoscope *)data;
 
+  if (rotoscope_marked_for_garbage_collection(config)) {
+    stop_tracing_on_cleanup(config);
+    return;
+  }
+
   if (config->tid != gettid()) return;
   if (in_fork(config)) {
     rb_tracepoint_disable(config->tracepoint);
@@ -165,77 +191,45 @@ static void event_hook(VALUE tpval, void *data) {
   }
 
   rb_trace_arg_t *trace_arg = rb_tracearg_from_tracepoint(tpval);
-  rb_event_flag_t event_flag = rb_tracearg_event_flag(trace_arg);
 
-  rs_callsite_t trace_path;
-  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;
+  if (rb_tracearg_defined_class(trace_arg) == cRotoscope) {
+    return;
   }
 
-  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;
+  rb_event_flag_t event_flag = rb_tracearg_event_flag(trace_arg);
 
-  if (config->flatten_output) {
-    if (event_flag & EVENT_CALL) {
-      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->log, stack_frame, caller_frame,
-                                  &config->call_memo);
+  if (event_flag & EVENT_RETURN) {
+    if (!rs_stack_empty(&config->stack)) {
+      rs_stack_pop(&config->stack);
     }
-  } else {
-    log_trace_event(config->log, &trace);
+    return;
   }
-}
 
-static void close_log_handle(Rotoscope *config) {
-  if (config->log) {
-    // Stop tracing so the event hook isn't called with a NULL log
-    if (config->state == RS_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.
-      if (RB_TYPE_P(config->tracepoint, T_DATA) &&
-          CLASS_OF(config->tracepoint) == cTracePoint) {
-        rb_tracepoint_disable(config->tracepoint);
-      }
-    }
+  rs_callsite_t trace_path = tracearg_path(trace_arg);
+  bool blacklisted = rejected_path(trace_path.filepath, config);
 
-    if (in_fork(config)) {
-      close(fileno(config->log));
-    } else {
-      fclose(config->log);
-    }
-    config->log = NULL;
-  }
+  rs_tracepoint_t trace = extract_full_tracevals(trace_arg, &trace_path);
+
+  rs_stack_push(&config->stack, trace, blacklisted);
+
+  if (blacklisted) return;
+
+  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);
 }
 
 static void rs_gc_mark(Rotoscope *config) {
-  rb_gc_mark(config->log_path);
+  rb_gc_mark(config->log);
   rb_gc_mark(config->tracepoint);
+  rb_gc_mark(config->output_buffer);
   rs_stack_mark(&config->stack);
 }
 
 void rs_dealloc(Rotoscope *config) {
-  close_log_handle(config);
+  stop_tracing_on_cleanup(config);
   rs_stack_free(&config->stack);
-  rs_strmemo_free(config->call_memo);
   xfree(config->blacklist);
   xfree(config);
 }
@@ -244,11 +238,13 @@ static VALUE rs_alloc(VALUE klass) {
   Rotoscope *config;
   VALUE self =
       Data_Make_Struct(klass, Rotoscope, rs_gc_mark, rs_dealloc, config);
-  config->log_path = Qnil;
+  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;
   return self;
 }
 
@@ -287,33 +283,21 @@ void copy_blacklist(Rotoscope *config, VALUE blacklist) {
 
 VALUE initialize(int argc, VALUE *argv, VALUE self) {
   Rotoscope *config = get_config(self);
-  VALUE output_path, blacklist, flatten;
+  VALUE output, blacklist;
 
-  rb_scan_args(argc, argv, "12", &output_path, &blacklist, &flatten);
-  Check_Type(output_path, T_STRING);
+  rb_scan_args(argc, argv, "11", &output, &blacklist);
 
   if (!NIL_P(blacklist)) {
     copy_blacklist(config, blacklist);
   }
 
-  config->flatten_output = RTEST(flatten);
-  config->log_path = output_path;
-  config->log = fopen(StringValueCStr(config->log_path), "w");
+  config->log = output;
 
-  if (config->log == NULL) {
-    fprintf(stderr, "\nERROR: Failed to open file handle at %s (%s)\n",
-            StringValueCStr(config->log_path), strerror(errno));
-    exit(1);
-  }
-
-  if (config->flatten_output)
-    write_csv_header(config->log, RS_FLATTENED_CSV_HEADER);
-  else
-    write_csv_header(config->log, RS_CSV_HEADER);
+  rb_io_write(config->log, str_header);
 
   rs_stack_init(&config->stack, STACK_CAPACITY);
-  config->call_memo = NULL;
   config->state = RS_OPEN;
+  config->output_buffer = rb_str_buf_new(LOG_BUFFER_SIZE);
   return self;
 }
 
@@ -335,36 +319,25 @@ VALUE rotoscope_stop_trace(VALUE self) {
   return Qnil;
 }
 
-VALUE rotoscope_log_path(VALUE self) {
-  Rotoscope *config = get_config(self);
-  return config->log_path;
-}
-
-VALUE rotoscope_mark(int argc, VALUE *argv, VALUE self) {
-  VALUE str;
-  rb_scan_args(argc, argv, "01", &str);
-
-  if (NIL_P(str)) str = rb_str_new2("");
-  Check_Type(str, T_STRING);
-
-  Rotoscope *config = get_config(self);
-  if (config->log != NULL && !in_fork(config)) {
-    rs_strmemo_free(config->call_memo);
-    fprintf(config->log, "--- %s\n", StringValueCStr(str));
-  }
-  return Qnil;
-}
-
 VALUE rotoscope_close(VALUE self) {
   Rotoscope *config = get_config(self);
   if (config->state == RS_CLOSED) {
     return Qtrue;
   }
-  close_log_handle(config);
+  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;
 }
 
+VALUE rotoscope_io(VALUE self) {
+  Rotoscope *config = get_config(self);
+  return config->log;
+}
+
 VALUE rotoscope_trace(VALUE self) {
   rotoscope_start_trace(self);
   return rb_ensure(rb_yield, Qundef, rotoscope_stop_trace, self);
@@ -387,24 +360,26 @@ void Init_rotoscope(void) {
 
   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);
+
   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, "mark", (VALUE(*)(ANYARGS))rotoscope_mark, -1);
   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, "log_path",
-                   (VALUE(*)(ANYARGS))rotoscope_log_path, 0);
   rb_define_method(cRotoscope, "state", (VALUE(*)(ANYARGS))rotoscope_state, 0);
 
   init_callsite();

data/ext/rotoscope/rotoscope.h

@@ -3,7 +3,6 @@
 
 #include <unistd.h>
 #include "stack.h"
-#include "strmemo.h"
 
 #define EVENT_CALL (RUBY_EVENT_CALL | RUBY_EVENT_C_CALL)
 #define EVENT_RETURN (RUBY_EVENT_RETURN | RUBY_EVENT_C_RETURN)
@@ -16,20 +15,10 @@
 
 // clang-format off
 
-#define RS_CSV_HEADER "event,entity,filepath,lineno,method_name,method_level"
-#define RS_CSV_FORMAT "%s,\"%s\",\"%s\",%d,\"%s\",%s"
-#define RS_CSV_VALUES(trace, method_name) \
-  trace->event,                           \
-  StringValueCStr((trace)->entity),       \
-  StringValueCStr((trace)->filepath),     \
-  (trace)->lineno,                        \
-  StringValueCStr(method_name),           \
-  (trace)->method_level
-
-#define RS_FLATTENED_CSV_HEADER \
+#define RS_CSV_HEADER \
   "entity,caller_entity,filepath,lineno,method_name,method_level,caller_method_name,caller_method_level"
-#define RS_FLATTENED_CSV_FORMAT "\"%s\",\"%s\",\"%s\",%d,\"%s\",%s,\"%s\",%s"
-#define RS_FLATTENED_CSV_VALUES(trace, caller_trace, method_name, caller_method_name) \
+#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),      \
@@ -48,17 +37,16 @@ typedef enum {
 } rs_state;
 
 typedef struct {
-  FILE *log;
-  VALUE log_path;
+  VALUE self;
+  VALUE log;
   VALUE tracepoint;
   const char **blacklist;
   unsigned long blacklist_size;
-  bool flatten_output;
   pid_t pid;
   unsigned long tid;
   rs_state state;
   rs_stack_t stack;
-  rs_strmemo_t *call_memo;
+  VALUE output_buffer;
 } Rotoscope;
 
 typedef struct {

data/lib/rotoscope.rb

@@ -1,56 +1,55 @@
 # frozen_string_literal: true
 require 'rotoscope/rotoscope'
-require 'fileutils'
-require 'tempfile'
 require 'csv'
 
 class Rotoscope
   class << self
-    def new(output_path, blacklist: [], flatten: false)
-      super(output_path, blacklist, flatten)
-    end
-
-    def trace(dest, blacklist: [], flatten: false, &block)
-      config = { blacklist: blacklist, flatten: flatten }
-      if dest.is_a?(String)
-        event_trace(dest, config, &block)
+    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
-        io_event_trace(dest, config, &block)
+        super(output, blacklist)
       end
     end
 
-    private
-
-    def with_temp_file(name)
-      temp_file = Tempfile.new(name)
-      yield temp_file
+    def trace(dest, blacklist: [])
+      rs = new(dest, blacklist: blacklist)
+      rs.trace { yield rs }
+      rs
     ensure
-      temp_file.close! if temp_file
+      rs.close if rs && dest.is_a?(String)
     end
 
-    def temp_event_trace(config, block)
-      with_temp_file("rotoscope_output") do |temp_file|
-        rs = event_trace(temp_file.path, config, &block)
-        yield rs
-        rs
-      end
-    end
+    private
 
-    def io_event_trace(dest_io, config, &block)
-      temp_event_trace(config, block) do |rs|
-        File.open(rs.log_path) do |rs_file|
-          IO.copy_stream(rs_file, dest_io)
-        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
 
-    def event_trace(dest_path, config)
-      rs = Rotoscope.new(dest_path, blacklist: config[:blacklist], flatten: config[:flatten])
-      rs.trace { yield rs }
-      rs
-    ensure
-      rs.close if rs
+  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)
+  ensure
+    start_trace if state == :tracing
   end
 
   def closed?