bleak_house 4.6 → 5

data/lib/bleak_house/bleak_house.rb

@@ -0,0 +1,43 @@
+
+class BleakHouse  
+  cattr_accessor :last_request_name
+
+  def self.set_request_name request, other = nil
+    self.last_request_name = "#{request.parameters['controller']}/#{request.parameters['action']}/#{request.request_method}#{other}"
+  end
+
+  def self.debug s
+    s = "#{name.underscore}: #{s}"
+    ::ActiveRecord::Base.logger.debug s if ::ActiveRecord::Base.logger
+  end
+    
+  def self.warn s
+    s = "#{name.underscore}: #{s}"
+    if ::ActiveRecord::Base.logger
+      ::ActiveRecord::Base.logger.warn s
+    else
+      $stderr.puts s
+    end
+  end
+
+  LOGFILE = "#{RAILS_ROOT}/log/bleak_house_#{RAILS_ENV}.dump"
+  if File.exists?(LOGFILE)
+    File.rename(LOGFILE, "#{LOGFILE}.old") 
+    warn "renamed old logfile"
+  end
+  
+  WITH_SPECIALS = false
+
+  MEMLOGGER = if ENV['MEMLOGGER'] !~ /ruby/i and (ENV['MEMLOGGER'] =~ /c/i or 
+    `which ruby-bleak-house` !~ /no ruby_bleak_house/)    
+    require 'bleak_house/c'
+    warn "using C instrumentation"
+    CLogger.new
+  else
+    require 'bleak_house/ruby'
+    warn "using pure Ruby instrumentation"
+    warn "(build the patched binary for speed and accuracy improvements)"
+    RubyLogger.new
+  end
+
+end

data/lib/bleak_house/c.rb

@@ -0,0 +1,184 @@
+
+require 'rubygems'
+require 'inline'
+
+class BleakHouse
+  class CLogger < MemLogger
+
+    MAX_UNIQ_TAGS = 1536 # per frame
+    MAX_TAG_LENGTH = 192 # tag plus fully namespaced classname
+
+    inline do |builder|
+      builder.include '"node.h"' # struct RNode
+      builder.include '"st.h"'  # struct st_table
+      builder.include '"re.h"'  # struct RRegexp
+      builder.include '"env.h"' # various structs
+
+      builder.prefix <<-EOC
+        typedef struct RVALUE {
+            union {
+                struct {
+                    unsigned long flags; /* always 0 for freed obj */
+                    struct RVALUE *next;
+                } free;
+                struct RBasic  basic;
+                struct RObject object;
+                struct RClass  klass;
+                struct RFloat  flonum;
+                struct RString string;
+                struct RArray  array;
+                struct RRegexp regexp;
+                struct RHash   hash;
+                struct RData   data;
+                struct RStruct rstruct;
+                struct RBignum bignum;
+                struct RFile   file;
+                struct RNode   node;
+                struct RMatch  match;
+                struct RVarmap varmap;
+                struct SCOPE   scope;
+            } as;
+        } RVALUE;
+
+        struct heaps_slot {
+            void *membase;
+            RVALUE *slot;
+            int limit;
+        };
+
+        struct heaps_slot * rb_gc_heap_slots();
+        int rb_gc_heaps_used();
+        int rb_gc_heaps_length();
+      EOC
+
+      # number of struct heaps_slots used
+      builder.c <<-EOC
+        static int
+        heaps_used() {
+          return rb_gc_heaps_used();
+        }
+      EOC
+
+      # length of the struct heaps_slots allocated
+      builder.c <<-EOC
+        static int
+        heaps_length() {
+          return rb_gc_heaps_length();
+        }
+      EOC
+
+      OBJ_TYPES = ["T_NIL",
+                  "T_OBJECT",
+                  "T_CLASS",
+                  "T_ICLASS",
+                  "T_MODULE",
+                  "T_FLOAT",
+                  "T_STRING",
+                  "T_REGEXP",
+                  "T_ARRAY",
+                  "T_FIXNUM",
+                  "T_HASH",
+                  "T_STRUCT",
+                  "T_BIGNUM",
+                  "T_FILE",
+                  "T_TRUE",
+                  "T_FALSE",
+                  "T_DATA",
+                  "T_SYMBOL",
+                  "T_MATCH"]
+
+      RAW_TYPES = ["T_NONE",
+                  "T_BLKTAG",
+                  "T_UNDEF",
+                  "T_VARMAP",
+                  "T_SCOPE",
+                  "T_NODE"]
+
+      # writes a frame to a file
+      builder.c <<-EOC
+        static void
+        VALUE snapshot(VALUE path, VALUE tag, VALUE _specials) {
+          Check_Type(path, T_STRING);
+          Check_Type(tag, T_STRING);
+
+          RVALUE *p, *pend;
+          struct heaps_slot * heaps = rb_gc_heap_slots();
+
+          int specials = RTEST(_specials);
+
+          FILE *obj_log = fopen(StringValueCStr(path), "r");
+          int is_new;
+          if (!(is_new = (obj_log == NULL)))
+            fclose(obj_log);
+
+          if ((obj_log = fopen(StringValueCStr(path), "a+")) == NULL)
+            rb_raise(rb_eRuntimeError, "couldn't open snapshot file");
+
+          if (is_new) 
+            fprintf(obj_log, \"---\\n");
+          fprintf(obj_log, \"- - %i\\n", time(0));
+          VALUE mem = rb_funcall(self, rb_intern("mem_usage"), 0);
+          fprintf(obj_log, \"  - :\\"memory usage/swap\\": %i\\n", NUM2INT(RARRAY_PTR(mem)[0]));
+          fprintf(obj_log, \"    :\\"memory usage/real\\": %i\\n", NUM2INT(RARRAY_PTR(mem)[1]));
+          
+          /* haha */
+          char tags[#{MAX_UNIQ_TAGS}][#{MAX_TAG_LENGTH}];
+          char current_tag[2048];
+          int counts[#{MAX_UNIQ_TAGS}];
+          int current_pos = 0;
+
+          int i, j;
+          for (i = 0; i < rb_gc_heaps_used(); i++) {
+            p = heaps[i].slot;
+            pend = p + heaps[i].limit;
+            for (; p < pend; p++) {
+              if (p->as.basic.flags) { /* always 0 for freed objects */
+                sprintf(current_tag, "");
+                switch (TYPE(p)) {
+                  #{RAW_TYPES.map do |type|
+                      "case #{type}:
+                          if (specials)
+                            sprintf(current_tag , \"%s::::_#{type[2..-1].downcase}\", StringValueCStr(tag));
+                          break;
+                      "
+                    end.flatten.join}
+                  default:
+                    if (!p->as.basic.klass) {
+                      sprintf(current_tag , "%s::::_unknown", StringValueCStr(tag));
+                    } else {
+                      sprintf(current_tag , "%s::::%s", StringValueCStr(tag), rb_obj_classname((VALUE)p));
+                    }
+                }
+                if (strlen(current_tag) > #{MAX_TAG_LENGTH})
+                  rb_raise(rb_eRuntimeError, "tag + classname too big; increase MAX_TAG_LENGTH (#{MAX_TAG_LENGTH})");
+                if (strcmp(current_tag, "")) {
+                  for (j = 0; j < current_pos; j++) {
+                    if (!strcmp(tags[j], current_tag)) {
+                      counts[j] ++;
+                      break;
+                    }
+                  }
+                  if (j == current_pos) {
+                    /* found a new one */
+                    if (current_pos == #{MAX_UNIQ_TAGS})
+                      rb_raise(rb_eRuntimeError, "exhausted tag array; increase MAX_UNIQ_TAGS (#{MAX_UNIQ_TAGS})");
+                    sprintf(tags[current_pos], current_tag);
+                    counts[current_pos] = 1;
+                    current_pos ++;
+                  }
+                }
+              }
+            }
+          }
+          
+          for (j = 0; j < current_pos; j++) {
+            fprintf(obj_log, "    :\\"%s\\": %i\\n", tags[j], counts[j]);
+          }
+          fclose(obj_log);
+          return Qtrue;
+        }
+      EOC
+    end
+
+  end
+end

data/lib/bleak_house/dispatcher.rb

@@ -0,0 +1,20 @@
+
+# crazyness
+
+class Dispatcher
+  class << self
+    def prepare_application_with_bleak_house
+      prepare_application_without_bleak_house
+      BleakHouse::MEMLOGGER.snapshot(BleakHouse::LOGFILE, 'core rails', BleakHouse::WITH_SPECIALS)
+      GC.start
+    end
+    alias_method_chain :prepare_application, :bleak_house
+    
+    def reset_after_dispatch_with_bleak_house
+      BleakHouse::MEMLOGGER.snapshot(BleakHouse::LOGFILE, BleakHouse.last_request_name || 'unknown', BleakHouse::WITH_SPECIALS)
+      GC.start
+      reset_after_dispatch_without_bleak_house
+    end
+    alias_method_chain :reset_after_dispatch, :bleak_house
+  end
+end

data/lib/bleak_house/gruff_hacks.rb

@@ -0,0 +1,62 @@
+
+class Gruff::Base
+  
+  def draw_legend
+    @legend_labels = @data.collect {|item| item[DATA_LABEL_INDEX] }
+
+    legend_square_width = @legend_box_size # small square with color of this item
+    legend_left = 10
+
+    current_x_offset = legend_left
+    current_y_offset =  TOP_MARGIN + TITLE_MARGIN + @title_caps_height + LEGEND_MARGIN
+
+    debug { @d.line 0.0, current_y_offset, @raw_columns, current_y_offset }
+                                                  
+    @legend_labels.each_with_index do |legend_label, index|      
+
+      next if index > MAX_LEGENDS
+      legend_label = "Some not shown" if index == MAX_LEGENDS
+
+      # Draw label
+      @d.fill = @font_color
+      @d.font = @font if @font
+      @d.pointsize = scale_fontsize(@legend_font_size)
+      @d.stroke('transparent')
+      @d.font_weight = NormalWeight
+      @d.gravity = WestGravity
+      @d = @d.annotate_scaled( @base_image, 
+                        @raw_columns, 1.0,
+                        current_x_offset + (legend_square_width * 1.7), current_y_offset, 
+                        legend_label.to_s, @scale)
+      
+      if index < MAX_LEGENDS
+      # Now draw box with color of this dataset
+        @d = @d.stroke('transparent')
+        @d = @d.fill @data[index][DATA_COLOR_INDEX]
+        @d = @d.rectangle(current_x_offset, 
+                          current_y_offset - legend_square_width / 2.0, 
+                          current_x_offset + legend_square_width, 
+                          current_y_offset + legend_square_width / 2.0)
+      end
+
+      @d.pointsize = @legend_font_size
+      metrics = @d.get_type_metrics(@base_image, legend_label.to_s)
+      current_y_offset += metrics.height * 1.05
+    end
+    @color_index = 0
+  end
+  
+  alias :setup_graph_measurements_without_top_margin :setup_graph_measurements
+  def setup_graph_measurements  
+    setup_graph_measurements_without_top_margin
+    @graph_height += NEGATIVE_TOP_MARGIN
+    @graph_top -= NEGATIVE_TOP_MARGIN    
+  end
+  
+  alias :clip_value_if_greater_than_without_size_hacks :clip_value_if_greater_than
+  def clip_value_if_greater_than(arg1, arg2)
+     arg2 = arg2 / 2 if arg1 == @columns / (@norm_data.first[1].size * 2.5)
+     clip_value_if_greater_than_without_size_hacks(arg1, arg2)
+  end
+  
+end

data/lib/bleak_house/mem_logger.rb

@@ -0,0 +1,15 @@
+
+class BleakHouse
+  class MemLogger
+    def snapshot
+      raise "abstract method; please require 'ruby' or 'c'"
+    end
+    
+    def mem_usage
+      a = `ps -o vsz,rss -p #{Process.pid}`.split(/\s+/)[-2..-1].map{|el| el.to_i}
+      [a.first - a.last, a.last]
+    end
+
+  end
+end
+

data/lib/bleak_house/rake_task_redefine_task.rb

@@ -0,0 +1,25 @@
+
+# http://www.bigbold.com/snippets/posts/show/2032
+module Rake
+  module TaskManager
+    def redefine_task(task_class, args, &block)
+      task_name, deps = resolve_args(args)
+      task_name = task_class.scope_name(@scope, task_name)
+      deps = [deps] unless deps.respond_to?(:to_ary)
+      deps = deps.collect {|d| d.to_s }
+      task = @tasks[task_name.to_s] = task_class.new(task_name, self)
+      task.application = self
+      task.add_comment(@last_comment)
+      @last_comment = nil
+      task.enhance(deps, &block)
+      task
+    end
+  end
+  class Task
+    class << self
+      def redefine_task(args, &block)
+        Rake.application.redefine_task(self, args, &block)
+      end
+    end
+  end
+end

data/lib/bleak_house/ruby.rb

@@ -0,0 +1,46 @@
+
+require 'yaml'
+
+class BleakHouse
+  class RubyLogger < MemLogger
+    SWAP = :"memory usage/swap"
+    RSS = :"memory usage/real"  
+    SEEN = {}
+    CURRENT = {}
+    TAGS = Hash.new(0)
+    
+    def snapshot(path, tag, _specials)
+      CURRENT.clear
+      ObjectSpace.each_object do |obj|
+        CURRENT[obj_id = obj._bleak_house_object_id] = true
+        unless SEEN[obj_id]
+          # symbols will rapidly stabilize
+          SEEN[obj_id] = "#{tag}::::#{obj._bleak_house_class}".to_sym 
+          TAGS[SEEN[obj_id]] += 1
+        end
+      end
+      SEEN.keys.each do |obj_id|
+        TAGS[SEEN.delete(obj_id)] -= 1 unless CURRENT[obj_id]          
+      end
+      CURRENT.clear
+
+      TAGS[SWAP], TAGS[RSS] = mem_usage
+                      
+      write(path)  
+    end        
+    
+    def write(path)
+      exists = File.exist? path
+      File.open(path, 'a+') do |log|
+        dump = YAML.dump([[Time.now.to_i, TAGS]])
+        log.write(exists ? dump[5..-1] : dump)
+      end      
+    end
+    
+  end
+end
+
+class Object
+  alias :_bleak_house_object_id :object_id
+  alias :_bleak_house_class  :class
+end

data/lib/bleak_house/support_methods.rb

@@ -0,0 +1,47 @@
+
+class Array
+  alias :time :first
+  alias :data :last
+  
+  def sum
+    inject(0) {|s, x| x + s}
+  end
+  
+  def to_i
+    self.map{|s| s.to_i}
+  end
+    
+end
+
+class Dir
+  def self.descend path, &block
+    path = path.split("/") unless path.is_a? Array
+    top = (path.shift or ".")
+    Dir.mkdir(top) unless File.exists? top
+    Dir.chdir(top) do
+      if path.any?
+        descend path, &block
+      else
+        block.call
+      end
+    end
+  end
+end
+
+class String
+  def to_filename
+    self.downcase.gsub(/[^\w\d\-]/, '_')
+  end
+end
+
+class NilClass
+  def +(op)
+    self.to_i + op
+  end
+end
+ 
+class Symbol
+  def =~ regex
+    self.to_s =~ regex
+  end
+end