pilfer 0.0.1.pre

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    N2VjNWFmMjYxZmMzNzYxOTI1YjZkNDVhNDVhMjE0MDYwY2NkYzBlMw==
+  data.tar.gz: !binary |-
+    MzRlMDIwMWIyZGMwY2QxZTY1ZTM4OTc1ZTU5MjA3YjU2NmFjYjA5OQ==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    YWExZjg4Y2ExOGVkYWQ3NTE0YjYwODdmOGQ5ODgxZDQwZGU1YjY3NDIyNzA0
+    MmY3OGRiMzk2ZmUyMDcyNDg4YTJjZmQwNDY1MjE3ZTY3ZjliNjhiNjIxYjIy
+    M2QyODdjODJjZTZjYTliMzI1MTQ1ZTRiM2Y0MzQ2MDVjODEwNGE=
+  data.tar.gz: !binary |-
+    ZTc3MzlkMmM5YTNkMzI0MGVjY2FhOGYxYmQzOTAxNzk4ZTA1ZWZmZWRjZGU1
+    OTMyZWU4YjFlODRiMDBkZTEzNTU4OTIwMDM3NDViMWRjYWIyNWQyMDE0OGU4
+    MTQ0NGExMjcwOTFhOTkwYTk3YTk4OTQ3NTYxNTI3MjUwZGU1ODc=

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+gem 'rblineprof', github: 'tmm1/rblineprof'
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 Eric Lindvall and Larry Marburger
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,112 @@
+# Pilfer
+
+Look into your ruby with [rblineprof](https://github.com/tmm1/rblineprof/).
+
+## Usage
+
+Profile a block of code saving the report to the file `profile.log`.
+
+```ruby
+reporter = Pilfer::Logger.new('pilfer.log')
+profiler = Pilfer::Profiler.new(reporter)
+profiler.profile { do_something }
+```
+
+The report prints the source of each line of code executed and includes the
+total execution time and the number of times the line was executed.
+
+_TODO: Show profile response._
+
+### Step 1: Create a reporter
+
+Profiles can be sent to a [pilfer-server][] or written to a file or `IO`
+object.
+
+```ruby
+reporter = Pilfer::Server.new('https://pilfer.com', 'abc123')
+reporter = Pilfer::Logger.new('pilfer.log')
+reporter = Pilfer::Logger.new($stdout)
+```
+
+The absolute path to each profiled file is used in the report. Set the path to
+the application root with `:app_root` to have it trimmed from reported file
+paths.
+
+```ruby
+reporter = Pilfer::Logger.new($stdout, :app_root => '/my/app')
+```
+
+### Step 2: Create a profiler
+
+Pass the reporter to a new `Pilfer::Profiler`.
+
+```ruby
+profiler = Pilfer::Profiler.new(reporter)
+```
+
+### Step 3: Profile a block of code
+
+Profile a block of code with `#profile`.
+
+```ruby
+profiler.profile { do_something }
+```
+
+Every file that's executed by the block--including code outside the
+application like gems and standard libraries--will be included in the profile.
+Use `#profile_files_matching` and provide a regular expression to limit
+profiling to only matching file paths.
+
+```ruby
+matcher = %r{^#{Regexp.escape(Rails.root.to_s)}/app/models}
+profiler.profile_files_matching(matcher) { do_something }
+```
+
+## Pilfer Server
+
+[pilfer-server][] is your own, personal service for collecting and viewing
+profile reports. Follow the [pilfer-server setup instructions][pilfer-server]
+to stand up a new server and send it reports using its URL and token.
+
+```ruby
+reporter = Pilfer::Server.new('https://pilfer.com', 'abc123')
+```
+
+## Rack Middleware
+
+Profile your Rack or Rails app using `Pilfer::Middleware`.
+
+```ruby
+reporter = Pilfer::Server.new('https://pilfer.com', 'abc123'
+                              :app_root => Rails.root)
+use Pilfer::Middleware, reporter
+```
+
+Restrict the files profiled by passing a regular expression with
+`:files_matching`.
+
+```ruby
+matcher = %r{^#{Regexp.escape(Rails.root.to_s)}/(app|config|lib|vendor/plugin)}
+use Pilfer::Middleware, reporter, :files_matching => matcher
+```
+
+You probably don't want to profile _every_ request. The given block will be
+evaluated on each request to determine if a profile should be run.
+
+```ruby
+use Pilfer::Middleware, reporter do
+  # Profile 1% of requests.
+  rand(100) == 1
+end
+```
+
+The Rack environment is available to allow profiling on demand.
+
+```ruby
+use Pilfer::Middleware, reporter do |env|
+  env.query_string.include? 'profile=true'
+end
+```
+
+
+[pilfer-server]: https://github.com/eric/pilfer-server

data/ext/extconf.rb

@@ -0,0 +1,19 @@
+require 'mkmf'
+
+if RUBY_VERSION >= "1.9"
+  require "debugger/ruby_core_source"
+
+  hdrs = proc {
+    have_type("rb_iseq_location_t", "vm_core.h")
+
+    have_header("vm_core.h") and
+    have_header("iseq.h")
+  }
+
+  unless Debugger::RubyCoreSource::create_makefile_with_core(hdrs, "rblineprof")
+    STDERR.puts "\nDebugger::RubyCoreSource::create_makefile failed"
+    exit(1)
+  end
+else
+  create_makefile 'rblineprof'
+end

data/ext/rblineprof.c

@@ -0,0 +1,619 @@
+#include <ruby.h>
+#include <stdbool.h>
+#include <time.h>
+#include <sys/time.h>
+#include <sys/resource.h>
+
+#ifdef RUBY_VM
+  #include <ruby/re.h>
+  #include <ruby/intern.h>
+  #include <vm_core.h>
+  #include <iseq.h>
+
+  // There's a compile error on 1.9.3. So:
+  #ifdef RTYPEDDATA_DATA
+  #define ruby_current_thread ((rb_thread_t *)RTYPEDDATA_DATA(rb_thread_current()))
+  #endif
+#else
+  #include <st.h>
+  #include <re.h>
+  #include <intern.h>
+  #include <node.h>
+  #include <env.h>
+  typedef rb_event_t rb_event_flag_t;
+#endif
+
+static VALUE gc_hook;
+
+/*
+ * Time in microseconds
+ */
+typedef uint64_t prof_time_t;
+
+/*
+ * Profiling snapshot
+ */
+typedef struct snapshot {
+  prof_time_t wall_time;
+  prof_time_t cpu_time;
+} snapshot_t;
+
+/*
+ * A line of Ruby source code
+ */
+typedef struct sourceline {
+  uint64_t calls; // total number of call/c_call events
+  snapshot_t total;
+} sourceline_t;
+
+/*
+ * Struct representing a single Ruby file.
+ */
+typedef struct sourcefile {
+  char *filename;
+
+  /* per line timing */
+  long nlines;
+  sourceline_t *lines;
+
+  /* overall file timing */
+  snapshot_t total;
+  snapshot_t child;
+  uint64_t depth;
+  snapshot_t exclusive_start;
+  snapshot_t exclusive;
+} sourcefile_t;
+
+/*
+ * An individual stack frame used to track
+ * calls and returns from Ruby methods
+ */
+typedef struct stackframe {
+  // data emitted from Ruby to our profiler hook
+  rb_event_flag_t event;
+#ifdef RUBY_VM
+  rb_thread_t *thread;
+#else
+  NODE *node;
+#endif
+  VALUE self;
+  ID mid;
+  VALUE klass;
+
+  char *filename;
+  long line;
+
+  snapshot_t start;
+  sourcefile_t *srcfile;
+} stackframe_t;
+
+/*
+ * Static properties and rbineprof configuration
+ */
+static struct {
+  bool enabled;
+
+  // stack
+  #define MAX_STACK_DEPTH 32768
+  stackframe_t stack[MAX_STACK_DEPTH];
+  uint64_t stack_depth;
+
+  // single file mode, store filename and line data directly
+  char *source_filename;
+  sourcefile_t file;
+
+  // regex mode, store file data in hash table
+  VALUE source_regex;
+  st_table *files;
+
+  // cache
+  struct {
+    char *file;
+    sourcefile_t *srcfile;
+  } cache;
+}
+rblineprof = {
+  .enabled = false,
+  .source_regex = Qfalse
+};
+
+static prof_time_t
+cputime_usec()
+{
+#if defined(__linux__)
+  struct timespec ts;
+
+  if (clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &ts) == 0) {
+    return (prof_time_t)ts.tv_sec*1e6 +
+           (prof_time_t)ts.tv_nsec*1e-3;
+  }
+#endif
+
+#if defined(RUSAGE_SELF)
+  struct rusage usage;
+
+  getrusage(RUSAGE_SELF, &usage);
+  return (prof_time_t)usage.ru_utime.tv_sec*1e6 +
+         (prof_time_t)usage.ru_utime.tv_usec;
+#endif
+
+  return 0;
+}
+
+static prof_time_t
+walltime_usec()
+{
+  struct timeval tv;
+  gettimeofday(&tv, NULL);
+  return (prof_time_t)tv.tv_sec*1e6 +
+         (prof_time_t)tv.tv_usec;
+}
+
+static inline snapshot_t
+snapshot_diff(snapshot_t *t1, snapshot_t *t2)
+{
+  snapshot_t diff = {
+    .wall_time         = t1->wall_time - t2->wall_time,
+    .cpu_time          = t1->cpu_time  - t2->cpu_time,
+  };
+
+  return diff;
+}
+
+static inline void
+snapshot_increment(snapshot_t *s, snapshot_t *inc)
+{
+  s->wall_time         += inc->wall_time;
+  s->cpu_time          += inc->cpu_time;
+}
+
+static inline void
+stackframe_record(stackframe_t *frame, snapshot_t now, stackframe_t *caller_frame)
+{
+  sourcefile_t *srcfile = frame->srcfile;
+  long line = frame->line;
+
+  /* allocate space for per-line data the first time */
+  if (srcfile->lines == NULL) {
+    srcfile->nlines = line + 100;
+    srcfile->lines = ALLOC_N(sourceline_t, srcfile->nlines);
+    MEMZERO(srcfile->lines, sourceline_t, srcfile->nlines);
+  }
+
+  /* grow the per-line array if necessary */
+  if (line >= srcfile->nlines) {
+    long prev_nlines = srcfile->nlines;
+    srcfile->nlines = line + 100;
+
+    REALLOC_N(srcfile->lines, sourceline_t, srcfile->nlines);
+    MEMZERO(srcfile->lines + prev_nlines, sourceline_t, srcfile->nlines - prev_nlines);
+  }
+
+  snapshot_t diff = snapshot_diff(&now, &frame->start);
+  sourceline_t *srcline = &(srcfile->lines[line]);
+
+  /* Line profiler metrics.
+   */
+
+  srcline->calls++;
+
+  /* Increment current line's total_time.
+   *
+   * Skip the special case where the stack frame we're returning to
+   * had the same file/line. This fixes double counting on crazy one-liners.
+   */
+  if (!(caller_frame && caller_frame->srcfile == frame->srcfile && caller_frame->line == frame->line))
+    snapshot_increment(&srcline->total, &diff);
+
+  /* File profiler metrics.
+   */
+
+  /* Increment the caller file's child_time.
+   */
+  if (caller_frame && caller_frame->srcfile != srcfile)
+    snapshot_increment(&caller_frame->srcfile->child, &diff);
+
+  /* Increment current file's total_time, but only when we return
+   * to the outermost stack frame when we first entered the file.
+   */
+  if (srcfile->depth == 0)
+    snapshot_increment(&srcfile->total, &diff);
+}
+
+static inline sourcefile_t*
+sourcefile_lookup(char *filename)
+{
+  sourcefile_t *srcfile = NULL;
+
+  if (rblineprof.source_filename) { // single file mode
+#ifdef RUBY_VM
+    if (strcmp(rblineprof.source_filename, filename) == 0) {
+#else
+    if (rblineprof.source_filename == filename) { // compare char*, not contents
+#endif
+      srcfile = &rblineprof.file;
+      srcfile->filename = filename;
+    } else {
+      return NULL;
+    }
+
+  } else { // regex mode
+    st_lookup(rblineprof.files, (st_data_t)filename, (st_data_t *)&srcfile);
+
+    if ((VALUE)srcfile == Qnil) // known negative match, skip
+      return NULL;
+
+    if (!srcfile) { // unknown file, check against regex
+      VALUE backref = rb_backref_get();
+      rb_match_busy(backref);
+      long rc = rb_reg_search(rblineprof.source_regex, rb_str_new2(filename), 0, 0);
+      rb_backref_set(backref);
+
+      if (rc >= 0) {
+        srcfile = ALLOC_N(sourcefile_t, 1);
+        MEMZERO(srcfile, sourcefile_t, 1);
+        srcfile->filename = strdup(filename);
+        st_insert(rblineprof.files, (st_data_t)srcfile->filename, (st_data_t)srcfile);
+      } else { // no match, insert Qnil to prevent regex next time
+        st_insert(rblineprof.files, (st_data_t)strdup(filename), (st_data_t)Qnil);
+        return NULL;
+      }
+    }
+  }
+
+  return srcfile;
+}
+
+#ifdef RUBY_VM
+/* Find the source of the current method call. This is based on rb_f_caller
+ * in vm_eval.c, and replicates the behavior of `caller.first` from ruby.
+ *
+ * On method calls, ruby 1.9 sends an extra RUBY_EVENT_CALL event with mid=0. The
+ * top-most cfp on the stack in these cases points to the 'def method' line, so we skip
+ * these and grab the second caller instead.
+ */
+static inline
+rb_control_frame_t *
+rb_vm_get_caller(rb_thread_t *th, rb_control_frame_t *cfp, ID mid)
+{
+  int level = 0;
+
+  while (!RUBY_VM_CONTROL_FRAME_STACK_OVERFLOW_P(th, cfp)) {
+    if (++level == 1 && mid == 0) {
+      // skip method definition line
+    } else if (cfp->iseq != 0 && cfp->pc != 0) {
+      return cfp;
+    }
+
+    cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
+  }
+
+  return 0;
+}
+
+#ifdef HAVE_TYPE_RB_ISEQ_LOCATION_T
+inline static int
+calc_lineno(const rb_iseq_t *iseq, const VALUE *pc)
+{
+  return rb_iseq_line_no(iseq, pc - iseq->iseq_encoded);
+}
+
+int
+rb_vm_get_sourceline(const rb_control_frame_t *cfp)
+{
+  int lineno = 0;
+  const rb_iseq_t *iseq = cfp->iseq;
+
+  if (RUBY_VM_NORMAL_ISEQ_P(iseq)) {
+    lineno = calc_lineno(cfp->iseq, cfp->pc);
+  }
+  return lineno;
+}
+#endif
+#endif
+
+static void
+#ifdef RUBY_VM
+profiler_hook(rb_event_flag_t event, VALUE data, VALUE self, ID mid, VALUE klass)
+#else
+profiler_hook(rb_event_flag_t event, NODE *node, VALUE self, ID mid, VALUE klass)
+#endif
+{
+  char *file;
+  long line;
+  stackframe_t *frame = NULL, *prev = NULL;
+  sourcefile_t *srcfile;
+
+  /* line profiler: maintain a stack of CALL events with timestamps. for
+   * each corresponding RETURN, account elapsed time to the calling line.
+   *
+   * we use ruby_current_node here to get the caller's file/line info,
+   * (as opposed to node, which points to the callee method being invoked)
+   */
+#ifndef RUBY_VM
+  NODE *caller_node = ruby_frame->node;
+  if (!caller_node) return;
+
+  file = caller_node->nd_file;
+  line = nd_line(caller_node);
+#else
+  rb_thread_t *th = ruby_current_thread;
+  rb_control_frame_t *cfp = rb_vm_get_caller(th, th->cfp, mid);
+  if (!cfp) return;
+
+  #ifdef HAVE_TYPE_RB_ISEQ_LOCATION_T
+    if (RTEST(cfp->iseq->location.absolute_path))
+      file = StringValueCStr(cfp->iseq->location.absolute_path);
+    else
+      file = StringValueCStr(cfp->iseq->location.path);
+  #else
+    if (RTEST(cfp->iseq->filepath))
+      file = StringValueCStr(cfp->iseq->filepath);
+    else
+      file = StringValueCStr(cfp->iseq->filename);
+  #endif
+  line = rb_vm_get_sourceline(cfp);
+#endif
+
+  if (!file) return;
+  if (line <= 0) return;
+
+  /* find the srcfile entry for the current file.
+   *
+   * first check the cache, in case this is the same file as
+   * the previous invocation.
+   *
+   * if no record is found, we don't care about profiling this
+   * file and return early.
+   */
+  if (rblineprof.cache.file == file)
+    srcfile = rblineprof.cache.srcfile;
+  else
+    srcfile = sourcefile_lookup(file);
+  rblineprof.cache.file = file;
+  rblineprof.cache.srcfile = srcfile;
+  if (!srcfile) return; /* skip line profiling for this file */
+
+  snapshot_t now = {
+    .wall_time         = walltime_usec(),
+    .cpu_time          = cputime_usec(),
+  };
+
+  switch (event) {
+    case RUBY_EVENT_CALL:
+    case RUBY_EVENT_C_CALL:
+      /* Create a stack frame entry with this event,
+       * the current file, and a snapshot of metrics.
+       *
+       * On a corresponding RETURN event later, we can
+       * pop this stack frame and accumulate metrics to the
+       * associated file and line.
+       */
+      rblineprof.stack_depth++;
+      if (rblineprof.stack_depth > 0 && rblineprof.stack_depth < MAX_STACK_DEPTH) {
+        frame = &rblineprof.stack[rblineprof.stack_depth-1];
+        frame->event = event;
+        frame->self = self;
+        frame->mid = mid;
+        frame->klass = klass;
+        frame->line = line;
+        frame->start = now;
+        frame->srcfile = srcfile;
+#ifdef RUBY_VM
+        frame->thread = th;
+#else
+        frame->node = node;
+#endif
+      }
+
+      /* Record when we entered this file for the first time.
+       * The difference is later accumulated into exclusive_time,
+       * e.g. on the next event if the file changes.
+       */
+      if (srcfile->depth == 0)
+        srcfile->exclusive_start = now;
+      srcfile->depth++;
+
+      if (rblineprof.stack_depth > 1) { // skip if outermost frame
+        prev = &rblineprof.stack[rblineprof.stack_depth-2];
+
+        /* If we just switched files, record time that was spent in
+         * the previous file.
+         */
+        if (prev->srcfile != frame->srcfile) {
+          snapshot_t diff = snapshot_diff(&now, &prev->srcfile->exclusive_start);
+          snapshot_increment(&prev->srcfile->exclusive, &diff);
+          prev->srcfile->exclusive_start = now;
+        }
+      }
+      break;
+
+    case RUBY_EVENT_RETURN:
+    case RUBY_EVENT_C_RETURN:
+      /* Find the corresponding CALL for this event.
+       *
+       * We loop here instead of a simple pop, because in the event of a
+       * raise/rescue several stack frames could have disappeared.
+       */
+      do {
+        if (rblineprof.stack_depth > 0 && rblineprof.stack_depth < MAX_STACK_DEPTH) {
+          frame = &rblineprof.stack[rblineprof.stack_depth-1];
+          if (frame->srcfile->depth > 0)
+            frame->srcfile->depth--;
+        } else
+          frame = NULL;
+
+        rblineprof.stack_depth--;
+      } while (frame &&
+#ifdef RUBY_VM
+               frame->thread != th &&
+#endif
+               /* Break when we find a matching CALL/C_CALL.
+                */
+               frame->event != (event == RUBY_EVENT_CALL ? RUBY_EVENT_RETURN : RUBY_EVENT_C_RETURN) &&
+               frame->self != self &&
+               frame->mid != mid &&
+               frame->klass != klass);
+
+      if (rblineprof.stack_depth > 0) {
+        // The new top of the stack (that we're returning to)
+        prev = &rblineprof.stack[rblineprof.stack_depth-1];
+
+        /* If we're leaving this frame to go back to a different file,
+         * accumulate time we spent in this file.
+         *
+         * Note that we do this both when entering a new file and leaving to
+         * a new file to ensure we only count time spent exclusively in that file.
+         * Consider the following scenario:
+         *
+         *     call (a.rb:1)
+         *       call (b.rb:1)         <-- leaving a.rb, increment into exclusive_time
+         *         call (a.rb:5)
+         *         return              <-- leaving a.rb, increment into exclusive_time
+         *       return
+         *     return
+         */
+        if (frame->srcfile != prev->srcfile) {
+          snapshot_t diff = snapshot_diff(&now, &frame->srcfile->exclusive_start);
+          snapshot_increment(&frame->srcfile->exclusive, &diff);
+          frame->srcfile->exclusive_start = now;
+          prev->srcfile->exclusive_start = now;
+        }
+      }
+
+      if (frame)
+        stackframe_record(frame, now, prev);
+
+      break;
+  }
+}
+
+static int
+cleanup_files(st_data_t key, st_data_t record, st_data_t arg)
+{
+  xfree((char *)key);
+
+  sourcefile_t *sourcefile = (sourcefile_t*)record;
+  if (!sourcefile || (VALUE)sourcefile == Qnil) return ST_DELETE;
+
+  if (sourcefile->lines)
+    xfree(sourcefile->lines);
+  xfree(sourcefile);
+
+  return ST_DELETE;
+}
+
+static int
+summarize_files(st_data_t key, st_data_t record, st_data_t arg)
+{
+  sourcefile_t *srcfile = (sourcefile_t*)record;
+  if (!srcfile || (VALUE)srcfile == Qnil) return ST_CONTINUE;
+
+  VALUE ret = (VALUE)arg;
+  VALUE ary = rb_ary_new();
+  long i;
+
+  rb_ary_store(ary, 0, rb_ary_new3(6,
+    ULL2NUM(srcfile->total.wall_time),
+    ULL2NUM(srcfile->child.wall_time),
+    ULL2NUM(srcfile->exclusive.wall_time),
+    ULL2NUM(srcfile->total.cpu_time),
+    ULL2NUM(srcfile->child.cpu_time),
+    ULL2NUM(srcfile->exclusive.cpu_time)
+  ));
+
+  for (i=1; i<srcfile->nlines; i++)
+    rb_ary_store(ary, i, rb_ary_new3(3,
+      ULL2NUM(srcfile->lines[i].total.wall_time),
+      ULL2NUM(srcfile->lines[i].total.cpu_time),
+      ULL2NUM(srcfile->lines[i].calls)
+    ));
+  rb_hash_aset(ret, rb_str_new2(srcfile->filename), ary);
+
+  return ST_CONTINUE;
+}
+
+static VALUE
+lineprof_ensure(VALUE self)
+{
+  rb_remove_event_hook((rb_event_hook_func_t) profiler_hook);
+  rblineprof.enabled = false;
+  return self;
+}
+
+VALUE
+lineprof(VALUE self, VALUE filename)
+{
+  if (!rb_block_given_p())
+    rb_raise(rb_eArgError, "block required");
+
+  if (rblineprof.enabled)
+    rb_raise(rb_eArgError, "profiler is already enabled");
+
+  VALUE filename_class = rb_obj_class(filename);
+
+  if (filename_class == rb_cString) {
+#ifdef RUBY_VM
+    rblineprof.source_filename = (char *) (StringValuePtr(filename));
+#else
+    /* rb_source_filename will return a string we can compare directly against
+     * node->file, without a strcmp()
+     */
+    rblineprof.source_filename = rb_source_filename(StringValuePtr(filename));
+#endif
+  } else if (filename_class == rb_cRegexp) {
+    rblineprof.source_regex = filename;
+    rblineprof.source_filename = NULL;
+  } else {
+    rb_raise(rb_eArgError, "argument must be String or Regexp");
+  }
+
+  // reset state
+  st_foreach(rblineprof.files, cleanup_files, 0);
+  if (rblineprof.file.lines) {
+    xfree(rblineprof.file.lines);
+    rblineprof.file.lines = NULL;
+    rblineprof.file.nlines = 0;
+  }
+  rblineprof.cache.file = NULL;
+  rblineprof.cache.srcfile = NULL;
+
+  rblineprof.enabled = true;
+#ifndef RUBY_VM
+  rb_add_event_hook((rb_event_hook_func_t) profiler_hook, RUBY_EVENT_CALL|RUBY_EVENT_RETURN|RUBY_EVENT_C_CALL|RUBY_EVENT_C_RETURN);
+#else
+  rb_add_event_hook((rb_event_hook_func_t) profiler_hook, RUBY_EVENT_CALL|RUBY_EVENT_RETURN|RUBY_EVENT_C_CALL|RUBY_EVENT_C_RETURN, Qnil);
+#endif
+
+  rb_ensure(rb_yield, Qnil, lineprof_ensure, self);
+
+  VALUE ret = rb_hash_new();
+  VALUE ary = Qnil;
+
+  if (rblineprof.source_filename) {
+    summarize_files(Qnil, (st_data_t)&rblineprof.file, ret);
+  } else {
+    st_foreach(rblineprof.files, summarize_files, ret);
+  }
+
+  return ret;
+}
+
+static void
+rblineprof_gc_mark()
+{
+  if (rblineprof.enabled)
+    rb_gc_mark_maybe(rblineprof.source_regex);
+}
+
+void
+Init_rblineprof()
+{
+  gc_hook = Data_Wrap_Struct(rb_cObject, rblineprof_gc_mark, NULL, NULL);
+  rb_global_variable(&gc_hook);
+
+  rblineprof.files = st_init_strtable();
+  rb_define_global_function("lineprof", lineprof, 1);
+}
+
+/* vim: set ts=2 sw=2 expandtab: */

data/lib/pilfer/logger.rb

@@ -0,0 +1,63 @@
+require 'pilfer/profile'
+
+module Pilfer
+  class Logger
+    attr_reader :path, :app_root
+
+    def initialize(path, options = {})
+      @path = path
+      if (app_root = options[:app_root])
+        app_root += '/' unless app_root[-1] == '/'
+        @app_root = %r{^#{Regexp.escape(app_root)}}
+      end
+    end
+
+    def write(profile_data, profile_start)
+      profile = Pilfer::Profile.new(profile_data, profile_start)
+      File.open(path, 'w') do |file|
+        print_report_banner file, profile_start
+        profile.each do |path, data|
+          print_file_banner file, path, data
+          print_file_source_with_profile file, path, data
+        end
+      end
+    end
+
+    private
+
+    def print_report_banner(file, profile_start)
+      file.puts '#' * 50
+      file.puts "# #{profile_start.utc.to_s}"
+      file.puts '#' * 50
+      file.puts
+    end
+
+    def print_file_banner(file, path, data)
+      wall = data['wall_time'] / 1000.0
+      cpu  = data['cpu_time']  / 1000.0
+      file.puts sprintf("%s wall_time=%.1fms cpu_time=%.1fms",
+                        strip_app_root(path), wall, cpu)
+    end
+
+    def print_file_source_with_profile(file, path, data)
+      File.readlines(path).each_with_index do |line_source, index|
+        line_profile = data['lines'][index]
+        if line_profile && line_profile['calls'] > 0
+          total = line_profile['wall_time']
+          file.puts sprintf("% 8.1fms (% 5d) | %s",
+                            total/1000.0,
+                            line_profile['calls'],
+                            line_source)
+        else
+          file.puts sprintf("                   | %s", line_source)
+        end
+      end
+      file.puts
+    end
+
+    def strip_app_root(path)
+      return path unless app_root
+      path.gsub(app_root, '')
+    end
+  end
+end

data/lib/pilfer/profile.rb

@@ -0,0 +1,39 @@
+module Pilfer
+  class Profile
+    include Enumerable
+    attr_accessor :data, :start
+
+    def initialize(data, start)
+      @data  = data
+      @start = start
+    end
+
+    def each(&block)
+      files.each(&block)
+    end
+
+    def files
+      data.each_with_object({}) do |(file, lines), files|
+        profile_lines = lines[1..-1].
+                          each_with_index.
+                          each_with_object({}) do |(data, number), lines|
+          next unless data.any? {|datum| datum > 0 }
+          wall_time, cpu_time, calls = data
+          lines[number] = { 'wall_time' => wall_time,
+                            'cpu_time'  => cpu_time,
+                            'calls'     => calls }
+        end
+
+        total_wall, child_wall, exclusive_wall,
+          total_cpu, child_cpu, exclusive_cpu = lines[0]
+
+        wall = total_wall
+        cpu  = total_cpu
+
+        files[file] = { 'wall_time' => wall,
+                        'cpu_time'  => cpu,
+                        'lines'     => profile_lines }
+      end
+    end
+  end
+end

data/lib/pilfer/profiler.rb

@@ -0,0 +1,25 @@
+require 'rblineprof'
+
+module Pilfer
+  class Profiler
+    attr_reader :reporter
+
+    def initialize(reporter)
+      @reporter = reporter
+    end
+
+    def profile(profiler = method(:lineprof), start = Time.now, &app)
+      profile_files_matching(/./, profiler, start, &app)
+    end
+
+    def profile_files_matching(matcher, profiler = method(:lineprof),
+                               start = Time.now, &app)
+      app_response = nil
+      profile = profiler.call(matcher) do
+        app_response = app.call
+      end
+      reporter.write profile, start
+      app_response
+    end
+  end
+end

data/lib/pilfer/version.rb

@@ -0,0 +1,3 @@
+module Pilfer
+  VERSION = '0.0.1.pre'
+end

data/pilfer.gemspec

@@ -0,0 +1,32 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'pilfer/version'
+
+Gem::Specification.new do |spec|
+  spec.name     = 'pilfer'
+  spec.version  = Pilfer::VERSION
+  spec.summary  = 'Look into your ruby with rblineprof'
+  spec.authors  = ['Eric Lindvall',       'Larry Marburger']
+  spec.email    = ['eric@sevenscale.com', 'larry@marburger.cc']
+  spec.homepage = 'https://github.com/eric/pilfer'
+  spec.license  = 'MIT'
+
+  spec.files = %w(Gemfile LICENSE README.md)
+  spec.files << 'pilfer.gemspec'
+  spec.files += Dir.glob('lib/**/*.rb')
+  spec.files += Dir.glob('test/**/*.rb')
+  spec.files += Dir.glob('script/*')
+  spec.test_files = Dir.glob('test/**/*.rb')
+
+  spec.add_development_dependency 'bundler', '~> 1.0'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rack', '~> 1.5.2'
+
+  spec.required_rubygems_version = '>= 1.3.6'
+
+  # Bundled latest rblineprof
+  spec.extensions = 'ext/extconf.rb'
+  spec.files += Dir.glob('ext/*')
+  spec.add_dependency 'debugger-ruby_core_source', '~> 1.2'
+end

data/script/package

@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+# Usage: script/package
+# Updates the gemspec and builds a new gem in the pkg directory.
+
+mkdir -p pkg
+gem build *.gemspec
+mv *.gem pkg

data/script/release

@@ -0,0 +1,15 @@
+#!/usr/bin/env bash
+# Usage: script/release
+# Build the package, tag a commit, push it to origin, and then release the
+# package publicly.
+
+set -e
+
+version="$(script/package | grep Version: | awk '{print $2}')"
+[ -n "$version" ] || exit 1
+
+git commit --allow-empty -a -m "Release $version"
+git tag "v$version"
+git push origin
+git push origin "v$version"
+gem push pkg/*-${version}.gem

metadata

@@ -0,0 +1,129 @@
+--- !ruby/object:Gem::Specification
+name: pilfer
+version: !ruby/object:Gem::Version
+  version: 0.0.1.pre
+platform: ruby
+authors:
+- Eric Lindvall
+- Larry Marburger
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-04-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.5.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.5.2
+- !ruby/object:Gem::Dependency
+  name: debugger-ruby_core_source
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.2'
+description: 
+email:
+- eric@sevenscale.com
+- larry@marburger.cc
+executables: []
+extensions:
+- ext/extconf.rb
+extra_rdoc_files: []
+files:
+- Gemfile
+- LICENSE
+- README.md
+- pilfer.gemspec
+- lib/pilfer/logger.rb
+- lib/pilfer/profile.rb
+- lib/pilfer/profiler.rb
+- lib/pilfer/version.rb
+- script/package
+- script/release
+- ext/extconf.rb
+- ext/rblineprof.c
+homepage: https://github.com/eric/pilfer
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.3.6
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Look into your ruby with rblineprof
+test_files: []