rotoscope 0.3.0.pre.1 → 0.3.0.pre.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8a94009a6d6ee2a34d124e8b922feb3ff3eda7f2
-  data.tar.gz: eab31fe889c50ea034197aa1a435ccb22c832630
+  metadata.gz: 214bc0f95d10e738330ccf96ad98195588ce2fed
+  data.tar.gz: c8be5f0941288a7a5242e830b17c98de16935022
 SHA512:
-  metadata.gz: 8ab381c724461c0b5dbab3a8dbbbf3e451c5aae060b8aecbaa9f28abc4d7aa636ecf7cd451b68537e104e13fc53c45243c47e4b44b48875f58bf1e32902a3f58
-  data.tar.gz: 5a598811ac79f0524d0e2d93d28a727a51e296cb575ed1de9b98e0f1b3921927b8557873e0bdcc682b8f7d09136f6d347c5d6eb2f8a7192bf39355a01e26f228
+  metadata.gz: 0af5d811380da0de299478d7176a09308c1c2ff3a54ea77be54df01e4c34213d8208407b30a90ef34b19d07395c34e2b08395db7a2ba0b0eb783dff8c039b5a8
+  data.tar.gz: 577ec0a7a6bfc747bc3cde9d80b854aab30cd4804f60ad844273b917741c78f8900d043e87b4eb9a0905884c421e282e0cfe991a62d37ebfef6b7906114bb10d

data/README.md

@@ -4,7 +4,7 @@ Rotoscope is a high-performance logger of Ruby method invocations.
 
 ## Status
 
-[![status](https://circleci.com/gh/Shopify/rotoscope/tree/master.svg?style=shield&circle-token=cddbd315df7a81ab944adf4dfc14a5800cd589fc)](https://circleci.com/gh/Shopify/rotoscope/tree/master) [![Gem Version](https://badge.fury.io/rb/rotoscope.svg)](https://badge.fury.io/rb/rotoscope)
+[![Build Status](https://travis-ci.org/Shopify/rotoscope.svg?branch=master)](https://travis-ci.org/Shopify/rotoscope) [![Gem Version](https://badge.fury.io/rb/rotoscope.svg)](https://badge.fury.io/rb/rotoscope)
 
 Rotoscope is subject to breaking changes in minor versions until `1.0` is available.
 

data/Rakefile

@@ -4,7 +4,9 @@
 # ==========================================================
 GEMSPEC = Gem::Specification.load('rotoscope.gemspec')
 
+require 'bundler/gem_tasks'
 require 'rubygems/package_task'
+
 Gem::PackageTask.new(GEMSPEC) do |pkg|
 end
 

data/ext/rotoscope/rotoscope.c

@@ -13,8 +13,8 @@
 #include "strmemo.h"
 #include "tracepoint.h"
 
-VALUE cRotoscope, cTracePoint;
-ID id_initialize;
+VALUE cRotoscope, cTracePoint, cInstructionSeq;
+ID id_initialize, id_of, id_label;
 
 static unsigned long gettid() {
   return NUM2ULONG(rb_obj_id(rb_thread_current()));
@@ -108,7 +108,6 @@ static rs_tracepoint_t extract_full_tracevals(rb_trace_arg_t *trace_arg,
 
   VALUE method_name = tracearg_method_name(trace_arg);
   VALUE filepath = callsite->filepath;
-
   return (rs_tracepoint_t){.event = evflag2name(event_flag),
                            .entity = method_owner.name,
                            .filepath = filepath,
@@ -119,30 +118,58 @@ static rs_tracepoint_t extract_full_tracevals(rb_trace_arg_t *trace_arg,
 
 static bool in_fork(Rotoscope *config) { return config->pid != getpid(); }
 
-static void log_trace_event(FILE *stream, rs_tracepoint_t *trace) {
-  fprintf(stream, RS_CSV_FORMAT "\n", RS_CSV_VALUES(trace));
+static VALUE unsafe_obj_method(VALUE argv) {
+  VALUE *args = (VALUE *)argv;
+  return rb_obj_method(args[0], args[1]);
 }
+static VALUE nil_method(VALUE *args) { return Qnil; }
 
-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;
-  }
+static bool endof_block_method(rb_trace_arg_t *trace_arg) {
+  VALUE method_id = rb_tracearg_method_id(trace_arg);
+  if (NIL_P(method_id)) return false;
 
-  snprintf((char *)output_buffer, LOG_BUFFER_SIZE, RS_FLATTENED_CSV_FORMAT "\n",
-           RS_FLATTENED_CSV_VALUES(&stack_frame->tp, &caller->tp));
+  VALUE self = rb_tracearg_self(trace_arg);
+  VALUE argv[2] = {self, method_id};
+  VALUE method = rb_rescue2(unsafe_obj_method, (VALUE)&argv, nil_method,
+                            (VALUE)&argv, rb_eNameError, (VALUE)0);
+  if (NIL_P(method)) return false;
+
+  VALUE iseq = rb_funcall(cInstructionSeq, id_of, 1, method);
+  if (!RTEST(iseq)) return false;
 
-  if (rs_strmemo_uniq(call_memo, output_buffer)) {
+  VALUE label = rb_funcall(iseq, id_label, 0);
+  char *label_str = StringValueCStr(label);
+  return strncmp(VM_BLOCK_PREFIX, label_str, strlen(VM_BLOCK_PREFIX)) == 0;
+}
+
+unsigned char output_buffer[LOG_BUFFER_SIZE];
+static void log_trace_event_with_caller(FILE *stream, rs_strmemo_t **call_memo,
+                                        rs_stack_frame_t frame) {
+  snprintf((char *)output_buffer, LOG_BUFFER_SIZE, RS_FLATTENED_CSV_FORMAT "\n",
+           RS_FLATTENED_CSV_VALUES(frame));
+  if (rs_strmemo_uniq(call_memo, (unsigned char *)output_buffer)) {
     fputs((char *)output_buffer, stream);
   }
 }
 
+static void log_trace_event(FILE *stream, rs_tracepoint_t trace) {
+  fprintf(stream, RS_CSV_FORMAT "\n", RS_CSV_VALUES(trace));
+}
+
+static bool invalid_stack_return(rs_stack_t *stack, rs_tracepoint_t *trace) {
+  rs_stack_frame_t *last_frame = rs_stack_peek(stack);
+  return !rs_raw_tracepoint_cmp(&trace->raw, &last_frame->tp.raw);
+}
+
+static void copy_filepath_from_caller(rs_stack_t *stack,
+                                      rs_tracepoint_t *trace) {
+  rs_stack_frame_t *last_frame = rs_stack_peek(stack);
+  trace->filepath = last_frame->tp.filepath;
+  trace->lineno = last_frame->tp.lineno;
+}
+
 static void event_hook(VALUE tpval, void *data) {
   Rotoscope *config = (Rotoscope *)data;
-
   if (config->tid != gettid()) return;
   if (in_fork(config)) {
     rb_tracepoint_disable(config->tracepoint);
@@ -152,39 +179,41 @@ 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;
+  rs_callsite_t trace_path = tracearg_path(trace_arg);
+  rs_raw_tracepoint_t raw_trace = rs_raw_from_tracepoint(tpval);
+
+  if (rejected_path(trace_path.filepath, config)) {
+    if (METHOD_CALL_P(event_flag)) return;
+    // We must ensure the event being blacklisted has correct filepath set,
+    // since block-method returns always point one level too high in the stack.
+
+    // Does this match the last caller?
+    rs_stack_frame_t *last_frame = rs_stack_peek(&config->stack);
+    if (!rs_raw_tracepoint_cmp(&raw_trace, &last_frame->tp.raw)) return;
+    // Are we dealing with a block return in wrong context?
+    if (!endof_block_method(trace_arg)) return;
   }
 
   rs_tracepoint_t trace = extract_full_tracevals(trace_arg, &trace_path);
+  trace.raw = raw_trace;
+
   if (!strcmp("Rotoscope", StringValueCStr(trace.entity))) return;
 
-  if (event_flag & EVENT_CALL) {
-    rs_stack_push(&config->stack, trace, blacklisted);
+  rs_stack_frame_t frame;
+  if (METHOD_CALL_P(event_flag)) {
+    frame = rs_stack_push(&config->stack, trace);
   } else {
+    if (invalid_stack_return(&config->stack, &trace)) return;
+    if (endof_block_method(trace_arg)) {
+      copy_filepath_from_caller(&config->stack, &trace);
+    }
     rs_stack_pop(&config->stack);
   }
 
-  if (blacklisted) return;
-
-  if (config->flatten_output) {
-    if (event_flag & EVENT_CALL) {
-      log_trace_event_with_caller(config->log, rs_stack_peek(&config->stack),
-                                  &config->call_memo);
-    }
-  } else {
-    log_trace_event(config->log, &trace);
+  if (!config->flatten_output) {
+    return log_trace_event(config->log, trace);
+  } else if (METHOD_CALL_P(event_flag)) {
+    log_trace_event_with_caller(config->log, &config->call_memo, frame);
   }
 }
 
@@ -313,7 +342,6 @@ 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;
@@ -368,9 +396,13 @@ VALUE rotoscope_state(VALUE self) {
 }
 
 void Init_rotoscope(void) {
+  VALUE cRubyVm = rb_const_get(rb_cObject, rb_intern("RubyVM"));
+  cInstructionSeq = rb_const_get(cRubyVm, rb_intern("InstructionSequence"));
   cTracePoint = rb_const_get(rb_cObject, rb_intern("TracePoint"));
 
   id_initialize = rb_intern("initialize");
+  id_of = rb_intern("of");
+  id_label = rb_intern("label");
 
   cRotoscope = rb_define_class("Rotoscope", rb_cObject);
   rb_define_alloc_func(cRotoscope, rs_alloc);

data/ext/rotoscope/rotoscope.h

@@ -7,10 +7,14 @@
 
 #define EVENT_CALL (RUBY_EVENT_CALL | RUBY_EVENT_C_CALL)
 #define EVENT_RETURN (RUBY_EVENT_RETURN | RUBY_EVENT_C_RETURN)
+#define METHOD_CALL_P(event) event &EVENT_CALL
+#define METHOD_RETURN_P(event) event &EVENT_RETURN
 
 #define CLASS_METHOD "class"
 #define INSTANCE_METHOD "instance"
 
+#define VM_BLOCK_PREFIX "block "
+
 #define STACK_CAPACITY 500
 #define LOG_BUFFER_SIZE 1000
 
@@ -18,24 +22,24 @@
 #define _RS_COMMON_CSV_HEADER "entity,method_name,method_level,filepath,lineno"
 #define _RS_COMMON_CSV_FORMAT "\"%s\",\"%s\",%s,\"%s\",%d"
 #define _RS_COMMON_CSV_VALUES(trace)  \
-  StringValueCStr((trace)->entity),      \
-  StringValueCStr((trace)->method_name), \
-  (trace)->method_level,                 \
-  StringValueCStr((trace)->filepath),    \
-  (trace)->lineno
+  StringValueCStr(trace.entity),      \
+  StringValueCStr(trace.method_name), \
+  trace.method_level,                 \
+  StringValueCStr(trace.filepath),    \
+  trace.lineno
 
 #define RS_CSV_HEADER "event," _RS_COMMON_CSV_HEADER
 #define RS_CSV_FORMAT "%s," _RS_COMMON_CSV_FORMAT
-#define RS_CSV_VALUES(trace) trace->event, _RS_COMMON_CSV_VALUES(trace)
+#define RS_CSV_VALUES(trace) trace.event, _RS_COMMON_CSV_VALUES(trace)
 
 #define RS_FLATTENED_CSV_HEADER \
   _RS_COMMON_CSV_HEADER ",caller_entity,caller_method_name,caller_method_level"
 #define RS_FLATTENED_CSV_FORMAT _RS_COMMON_CSV_FORMAT ",\"%s\",\"%s\",%s"
-#define RS_FLATTENED_CSV_VALUES(trace, caller_trace) \
-  _RS_COMMON_CSV_VALUES(trace),               \
-  StringValueCStr((caller_trace)->entity),      \
-  StringValueCStr((caller_trace)->method_name), \
-  (caller_trace)->method_level
+#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
 // 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, false);
+  rs_stack_push(stack, root_trace);
 }
 
 static void resize_buffer(rs_stack_t *stack) {
@@ -31,16 +31,15 @@ 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) {
+rs_stack_frame_t rs_stack_push(rs_stack_t *stack, rs_tracepoint_t trace) {
   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, .blacklisted = blacklisted};
+  rs_stack_frame_t new_frame =
+      (rs_stack_frame_t){.tp = trace, .caller = caller};
 
   stack->contents[++stack->top] = new_frame;
   return new_frame;

data/ext/rotoscope/stack.h

@@ -1,5 +1,6 @@
 #ifndef _INC_ROTOSCOPE_STACK_H_
 #define _INC_ROTOSCOPE_STACK_H_
+
 #include <stdbool.h>
 #include "tracepoint.h"
 
@@ -7,7 +8,6 @@
 
 typedef struct rs_stack_frame_t {
   struct rs_tracepoint_t tp;
-  bool blacklisted;
   struct rs_stack_frame_t *caller;
 } rs_stack_frame_t;
 
@@ -20,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, bool backlisted);
+rs_stack_frame_t rs_stack_push(rs_stack_t *stack, rs_tracepoint_t trace);
 bool rs_stack_empty(rs_stack_t *stack);
 bool rs_stack_full(rs_stack_t *stack);
 rs_stack_frame_t rs_stack_pop(rs_stack_t *stack);

data/ext/rotoscope/tracepoint.c

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

data/ext/rotoscope/tracepoint.h

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

data/lib/rotoscope/version.rb

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

metadata

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