stack_tracy 0.1.0

data/bin/tracy

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+require "rubygems"
+require "stack_tracy"
+
+begin
+  StackTracy.open ARGV.first
+rescue StackTracy::Error => e
+  puts e.message.red
+end

data/ext/stack_tracy/extconf.rb

@@ -0,0 +1,4 @@
+# See http://guides.rubygems.org/c-extensions and http://www.rubyinside.com/how-to-create-a-ruby-extension-in-c-in-under-5-minutes-100.html
+require "mkmf"
+dir_config "stack_tracy"
+create_makefile "stack_tracy"

data/ext/stack_tracy/stack_tracy.c

@@ -0,0 +1,216 @@
+#include "stack_tracy.h"
+
+static double nsec() {
+  #if defined(__linux__)
+    struct timespec clock;
+    clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &clock);
+    return (clock.tv_sec * 1000000000 + clock.tv_nsec) / 1000000000.0;
+  #elif defined(_win32)
+    FILETIME createTime;
+    FILETIME exitTime;
+    FILETIME sysTime;
+    FILETIME cpuTime;
+
+    ULARGE_INTEGER sysTimeInt;
+    ULARGE_INTEGER cpuTimeInt;
+    ULONGLONG totalTime;
+
+    GetProcessTimes(GetCurrentProcess(), &createTime, &exitTime, &sysTime, &cpuTime);
+
+    /* Doing this based on MSFT's recommendation in the FILETIME structure documentation at
+      http://msdn.microsoft.com/en-us/library/ms724284%28VS.85%29.aspx*/
+
+    sysTimeInt.LowPart = sysTime.dwLowDateTime;
+    sysTimeInt.HighPart = sysTime.dwHighDateTime;
+    cpuTimeInt.LowPart = cpuTime.dwLowDateTime;
+    cpuTimeInt.HighPart = cpuTime.dwHighDateTime;
+
+    totalTime = sysTimeInt.QuadPart + cpuTimeInt.QuadPart;
+
+    // Times are in 100-nanosecond time units.  So instead of 10-9 use 10-7
+    return totalTime / 10000000.0;
+  #else
+    return ((double) clock()) / CLOCKS_PER_SEC;
+  #endif
+}
+
+static const char *event_name(rb_event_flag_t event) {
+  switch (event) {
+    case RUBY_EVENT_LINE:
+  return "line";
+    case RUBY_EVENT_CLASS:
+  return "class";
+    case RUBY_EVENT_END:
+  return "end";
+    case RUBY_EVENT_CALL:
+  return "call";
+    case RUBY_EVENT_RETURN:
+  return "return";
+    case RUBY_EVENT_C_CALL:
+  return "c-call";
+    case RUBY_EVENT_C_RETURN:
+  return "c-return";
+    case RUBY_EVENT_RAISE:
+  return "raise";
+  #ifdef RUBY_VM
+    case RUBY_EVENT_SWITCH:
+  return "thread-interrupt";
+  #endif
+    default:
+  return "unknown";
+  }
+}
+
+#if defined(RB_EVENT_HOOKS_HAVE_CALLBACK_DATA) || defined(RUBY_EVENT_VM)
+static void stack_tracy_trap(rb_event_flag_t event, VALUE data, VALUE self, ID id, VALUE klass)
+#else
+static void stack_tracy_trap(rb_event_flag_t event, NODE *node, VALUE self, ID id, VALUE klass)
+#endif
+{
+  int i;
+  bool singleton = false, match = false;
+  EventInfo info;
+
+  if (event == RUBY_EVENT_CALL || event == RUBY_EVENT_C_CALL) {
+    trace = true;
+  }
+
+  if (trace == false) {
+    return;
+  }
+
+  #ifdef RUBY_VM
+  if (id == 0) {
+    rb_frame_method_id_and_class(&id, &klass);
+  }
+  #endif
+
+  if (klass) {
+    if (TYPE(klass) == T_ICLASS) {
+      klass = RBASIC(klass)->klass;
+    }
+
+    singleton = FL_TEST(klass, FL_SINGLETON);
+
+    #ifdef RUBY_VM
+    if (singleton && !(TYPE(self) == T_CLASS || TYPE(self) == T_MODULE))
+      singleton = false;
+    #endif
+  }
+
+  info.method = (ID *) id;
+
+  if (info.method != NULL) {
+    info.object = (VALUE *)(singleton ? self : klass);
+
+    if (info.object) {
+      for (i = 0; i < exclude_size; i++) {
+        if (((VALUE) exclude[i].klass) == (VALUE) info.object) {
+          return;
+        }
+      }
+
+      if (only_size > 0) {
+        match = false;
+        for (i = 0; i < only_size; i++) {
+          match = match || (((VALUE) only[i].klass) == (VALUE) info.object);
+        }
+        if (!match) {
+          return;
+        }
+      }
+
+      info.event = event;
+      info.file = (char *) rb_sourcefile();
+      info.line = rb_sourceline();
+      info.singleton = singleton;
+      info.nsec = nsec();
+
+      stack_size = stack_size + 1;
+      stack = (EventInfo *) realloc (stack, stack_size * sizeof(EventInfo));
+      stack[stack_size - 1] = info;
+    }
+  }
+}
+
+VALUE stack_tracy_start(VALUE self, VALUE only_names, VALUE exclude_names) {
+  int i;
+  char *token;
+
+  token = strtok((char *) RSTRING_PTR(only_names), " ");
+  only_size = 0;
+
+  while (token != NULL) {
+    only_size++;
+    only = (RubyClass *) realloc (only, only_size * sizeof(RubyClass));
+
+    RubyClass klass;
+    klass.name = (char *) token;
+    klass.klass = (VALUE *) rb_path2class((char *) token);
+    only[only_size - 1] = klass;
+
+    token = strtok(NULL, " ");
+  }
+
+  token = strtok((char *) RSTRING_PTR(exclude_names), " ");
+  exclude_size = 0;
+
+  while (token != NULL) {
+    exclude_size++;
+    exclude = (RubyClass *) realloc (exclude, exclude_size * sizeof(RubyClass));
+
+    RubyClass klass;
+    klass.name = (char *) token;
+    klass.klass = (VALUE *) rb_path2class((char *) token);
+    exclude[exclude_size - 1] = klass;
+
+    token = strtok(NULL, " ");
+  }
+
+  #if defined(RB_EVENT_HOOKS_HAVE_CALLBACK_DATA) || defined(RUBY_EVENT_VM)
+    rb_add_event_hook(stack_tracy_trap, RUBY_EVENT_CALL | RUBY_EVENT_C_CALL | RUBY_EVENT_RETURN | RUBY_EVENT_C_RETURN, 0);
+  #else
+    rb_add_event_hook(stack_tracy_trap, RUBY_EVENT_CALL | RUBY_EVENT_C_CALL | RUBY_EVENT_RETURN | RUBY_EVENT_C_RETURN);
+  #endif
+
+  stack_size = 0, trace = false;
+
+  return Qnil;
+}
+
+VALUE stack_tracy_stop(VALUE self) {
+  VALUE events, event;
+  ID id;
+  const char *method;
+  int i;
+
+  rb_remove_event_hook(stack_tracy_trap);
+
+  events = rb_ary_new();
+
+  for (i = 0; i < stack_size - 2; i++) {
+    method = rb_id2name((ID) stack[i].method);
+    if (method != NULL) {
+      event = rb_funcall(cEventInfo, rb_intern("new"), 0);
+      rb_iv_set(event, "@event", rb_str_new2(event_name(stack[i].event)));
+      rb_iv_set(event, "@file", rb_str_new2(stack[i].file));
+      rb_iv_set(event, "@line", rb_int_new(stack[i].line));
+      rb_iv_set(event, "@singleton", stack[i].singleton);
+      rb_iv_set(event, "@object", (VALUE) stack[i].object);
+      rb_iv_set(event, "@method", rb_str_new2(method));
+      rb_iv_set(event, "@nsec", rb_float_new(stack[i].nsec));
+      rb_ary_push(events, event);
+    }
+  }
+
+  rb_iv_set(mStackTracy, "@stack_trace", events);
+
+  return Qnil;
+}
+
+void Init_stack_tracy() {
+  mStackTracy = rb_const_get(rb_cObject, rb_intern("StackTracy"));
+  cEventInfo = rb_const_get(mStackTracy, rb_intern("EventInfo"));
+  rb_define_singleton_method(mStackTracy, "_start", stack_tracy_start, 2);
+  rb_define_singleton_method(mStackTracy, "_stop", stack_tracy_stop, 0);
+}

data/ext/stack_tracy/stack_tracy.h

@@ -0,0 +1,48 @@
+#ifndef STACK_TRACY_H
+#define STACK_TRACY_H
+
+#include <ruby.h>
+#include <stdbool.h>
+#include <time.h>
+#include <sys/time.h>
+#include <string.h>
+
+typedef struct event_info_t {
+  rb_event_flag_t event;
+  const char *file;
+  int line;
+  bool singleton;
+  const VALUE *object;
+  const ID *method;
+  double nsec;
+} EventInfo;
+
+typedef struct ruby_class_t {
+  const char *name;
+  const VALUE *klass;
+} RubyClass;
+
+static VALUE mStackTracy;
+static VALUE cEventInfo;
+
+static EventInfo *stack;
+static RubyClass *only;
+static RubyClass *exclude;
+
+static int stack_size, only_size, exclude_size;
+static bool trace;
+
+static double nsec();
+static const char *event_name(rb_event_flag_t event);
+
+#if defined(RB_EVENT_HOOKS_HAVE_CALLBACK_DATA) || defined(RUBY_EVENT_VM)
+static void stack_tracy_trap(rb_event_flag_t event, VALUE data, VALUE self, ID id, VALUE klass);
+#else
+static void stack_tracy_trap(rb_event_flag_t event, NODE *node, VALUE self, ID id, VALUE klass);
+#endif
+
+VALUE stack_tracy_start(VALUE self, VALUE only_names, VALUE exclude_names);
+VALUE stack_tracy_stop(VALUE self);
+void Init_stack_tracy();
+
+#endif

data/lib/stack_tracy.rb

@@ -0,0 +1,162 @@
+require "erb"
+require "csv"
+require "tmpdir"
+require "securerandom"
+require "rich/support/core/string/colorize"
+require "launchy"
+
+require "stack_tracy/core_ext"
+require "stack_tracy/event_info"
+require "stack_tracy/sinatra"
+require "stack_tracy/version"
+
+module StackTracy
+  extend self
+
+  PRESETS = {
+    :core => "Array BasicObject Enumerable Fixnum Float Hash IO Integer Kernel Module Mutex Numeric Object Rational String Symbol Thread Time",
+    :active_record => "ActiveRecord::Base",
+    :data_mapper => "DataMapper::Resource"
+  }
+  @options = Struct.new(:dump_dir, :only, :exclude).new(Dir::tmpdir)
+
+  class Error < StandardError; end
+
+  def config
+    yield @options
+  end
+
+  def start(options = {})
+    opts = merge_options(options)
+    _start mod_names(opts[:only]), mod_names(opts[:exclude])
+    nil
+  end
+
+  def stop
+    _stop
+    nil
+  end
+
+  def stack_trace
+    @stack_trace || []
+  end
+
+  def select(*only)
+    [].tap do |lines|
+      first, call_stack, only = nil, [], only.flatten.collect{|x| x.split(" ")}.flatten
+      stack_trace.each do |event_info|
+        next unless process?(event_info, only)
+        first ||= event_info
+        if event_info.call?
+          lines << event_info.to_hash(first).merge!(:depth => call_stack.size)
+          call_stack << [lines.size - 1, event_info]
+        elsif event_info.return? && call_stack.last && event_info.matches?(call_stack.last.last)
+          call_stack.pop.tap do |(line, match)|
+            lines[line][:duration] = event_info - match
+          end
+        end
+      end
+    end
+  end
+
+  def print(*only)
+    puts select(only).collect{ |event|
+      line = "   " * event[:depth]
+      line << event[:call]
+      line << " <#{"%.6f" % event[:duration]}>" if event[:duration]
+    }
+  end
+
+  def dump(path = nil, *only)
+    unless path && path.match(/\.csv$/)
+      path = File.join [path || @options.dump_dir, "stack_events-#{SecureRandom.hex(3)}.csv"].compact
+    end
+    File.expand_path(path).tap do |path|
+      keys = [:event, :file, :line, :singleton, :object, :method, :nsec, :time, :call, :depth, :duration]
+      File.open(path, "w") do |file|
+        file << keys.join(";") + "\n"
+        select(only).each do |event|
+          file << event.values_at(*keys).join(";") + "\n"
+        end
+      end
+    end
+  end
+
+  def open(path = nil, use_current_stack_trace = false)
+    unless use_current_stack_trace
+      unless path && path.match(/\.csv$/)
+        path = Dir[File.join(path || @options.dump_dir, "stack_events-*.csv")].sort_by{|f| File.mtime(f)}.last
+        path ||= Dir[File.join(path || Dir::tmpdir, "stack_events-*.csv")].sort_by{|f| File.mtime(f)}.last
+      end
+      if path
+        file = File.expand_path(path)
+      else
+        raise Error, "Could not locate StackTracy file"
+      end
+    end
+
+    index = ui("index.html")
+
+    if use_current_stack_trace || (file && File.exists?(file))
+      events = use_current_stack_trace ? select : StackTracy::EventInfo.to_hashes(File.read(file))
+      erb = ERB.new File.new(ui("index.html.erb")).read
+      File.open(index, "w"){|f| f.write erb.result(binding)}
+    elsif path && path.match(/\.csv$/)
+      raise Error, "Could not locate StackTracy file at #{file}"
+    end
+
+    if File.exists?(index)
+      Launchy.open("file://#{index}")
+      nil
+    else
+      raise Error, "Could not locate StackTracy file"
+    end
+  end
+
+private
+
+  def merge_options(hash = {})
+    {:only => @options.only, :exclude => @options.exclude}.merge(hash.inject({}){|h, (k, v)| h.merge!(k.to_sym => v)})
+  end
+
+  def mod_names(arg)
+    names = PRESETS.inject([arg || []].flatten.collect(&:to_s).join(" ")){|s, (k, v)| s.gsub k.to_s, v}
+    if names.include?("*")
+      names.split(/\s/).collect do |name|
+        name.include?("*") ? mods_within([constantize(name.gsub("*", ""))]).collect(&:name) : spec
+      end.flatten
+    else
+      names.split(/\s/)
+    end.sort.join(" ")
+  end
+
+  def constantize(name)
+    name.split("::").inject(Kernel){|m, x| m.const_get x}
+  end
+
+  def mods_within(mods, initial_array = nil)
+    (initial_array || mods).tap do |array|
+      mods.each do |mod|
+        mod.constants.each do |c|
+          const = mod.const_get c
+          if !array.include?(const) && (const.is_a?(Class) || const.is_a?(Module)) && const.name.match(/^#{mod.name}/)
+            array << const
+            mods_within([const], array)
+          end
+        end
+      end
+    end
+  end
+
+  def process?(event_info, only)
+    return true if only.empty?
+    only.any?{|x| event_info.matches?(x)}
+  end
+
+  def ui(file)
+    File.expand_path("../../ui/#{file}", __FILE__)
+  end
+
+end
+
+require File.expand_path("../../ext/stack_tracy/stack_tracy", __FILE__)

data/lib/stack_tracy/core_ext.rb

@@ -0,0 +1,3 @@
+Dir["#{File.dirname(__FILE__)}/core_ext/*.rb"].sort.each do |path|
+  require path
+end