em-monitor 0.1

data/Rakefile

@@ -0,0 +1,6 @@
+
+task :test do
+  exec 'ruby ./test/*.rb'
+end
+
+task :default => [:test]

data/em-monitor.gemspec

@@ -0,0 +1,22 @@
+Gem::Specification.new do |gem|
+  gem.name = 'em-monitor'
+  gem.version = '0.1'
+
+  gem.summary = 'Monitor the distribution of your eventmachine CPU usage'
+  gem.description = "EventLoops are awesome unless you're doing a lot of blocking CPU stuff, at which point they become useless.
+                     This gem lets you easily graph the lengths of CPU-blocked spans so that you can take action to make your
+                     eventmachine server faster"
+
+  gem.authors = ['Conrad Irwin']
+  gem.email = %w(conrad@rapportive.com)
+  gem.homepage = 'http://github.com/ConradIrwin/em-monitor'
+
+  gem.license = 'MIT'
+
+  gem.required_ruby_version = '>= 1.9.3'
+
+  gem.add_dependency 'eventmachine'
+  gem.add_dependency 'lspace'
+
+  gem.files = `git ls-files`.split("\n")
+end

data/example/gnuplot.rb

@@ -0,0 +1,29 @@
+require 'em-monitor'
+require 'time'
+
+at_exit do
+  exec %(gnuplot -e 'load "example/stacked.plot"' -p)
+end
+
+puts "When you've gathered enough data (about 30s should be enough) hit <Ctrl-C>"
+
+EM::run do
+  file = File.open("/tmp/to_plot", "w")
+
+  # Every second, output the % of time spent in CPU-spans of various lengths in a
+  # gnuplot-readable format.
+  EM::monitor_histogram(interval: 1, stacked: true) do |hist, from, to|
+    percentages = hist.map{ |k, v| (v * 100 / (to - from)) }
+
+    file.puts "#{Time.now.utc.iso8601} #{percentages.join(" ")}"
+    file.flush
+    puts "#{Time.now.utc.iso8601} #{percentages.map{ |x| "%0.2f" % x }.join(" ")}"
+  end
+
+  # Generate some sample data.
+  samples = [0.0005] * 100000 + [0.005] * 10000 + [0.05] * 1000 + [0.5] * 100 + [5] * 10 + [10] * 1
+  EM::PeriodicTimer.new(rand * 0.02) do
+    sleep samples.sample
+  end
+end
+

data/example/stacked.plot

@@ -0,0 +1,160 @@
+#!/usr/bin/gnuplot -persist
+#
+#
+#   See example/gnuplot.rb for how to use this!
+#
+#
+#
+#    
+#    	G N U P L O T
+#    	Version 4.6 patchlevel 0    last modified 2012-03-04 
+#    	Build System: Linux x86_64
+#    
+#    	Copyright (C) 1986-1993, 1998, 2004, 2007-2012
+#    	Thomas Williams, Colin Kelley and many others
+#    
+#    	gnuplot home:     http://www.gnuplot.info
+#    	faq, bugs, etc:   type "help FAQ"
+#    	immediate help:   type "help"  (plot window: hit 'h')
+# set terminal wxt 0
+# set output
+unset clip points
+set clip one
+unset clip two
+set bar 1.000000 front
+set border 31 front linetype -1 linewidth 1.000
+set timefmt z "%Y-%m-%dT%H:%M:%SZ"
+set zdata 
+set timefmt y "%Y-%m-%dT%H:%M:%SZ"
+set ydata 
+set timefmt x "%Y-%m-%dT%H:%M:%SZ"
+set xdata time
+set timefmt cb "%Y-%m-%dT%H:%M:%SZ"
+set timefmt y2 "%Y-%m-%dT%H:%M:%SZ"
+set y2data 
+set timefmt x2 "%Y-%m-%dT%H:%M:%SZ"
+set x2data 
+set boxwidth
+set style fill  empty border
+set style rectangle back fc  lt -3 fillstyle   solid 1.00 border lt -1
+set style circle radius graph 0.02, first 0, 0 
+set style ellipse size graph 0.05, 0.03, first 0 angle 0 units xy
+set dummy x,y
+set format x "% g"
+set format y "% g"
+set format x2 "% g"
+set format y2 "% g"
+set format z "% g"
+set format cb "% g"
+set format r "% g"
+set angles radians
+unset grid
+set raxis
+set key title ""
+set key inside right top vertical Right noreverse enhanced autotitles nobox
+set key noinvert samplen 4 spacing 1 width 0 height 0 
+set key maxcolumns 0 maxrows 0
+set key noopaque
+unset label
+unset arrow
+set style increment default
+unset style line
+unset style arrow
+set style histogram clustered gap 2 title  offset character 0, 0, 0
+unset logscale
+set offsets 0, 0, 0, 0
+set pointsize 1
+set pointintervalbox 1
+set encoding default
+unset polar
+unset parametric
+unset decimalsign
+set view 60, 30, 1, 1
+set samples 100, 100
+set isosamples 10, 10
+set surface
+unset contour
+set clabel '%8.3g'
+set mapping cartesian
+set datafile separator whitespace
+unset hidden3d
+set cntrparam order 4
+set cntrparam linear
+set cntrparam levels auto 5
+set cntrparam points 5
+set size ratio 0 1,1
+set origin 0,0
+set style data points
+set style function lines
+set xzeroaxis linetype -2 linewidth 1.000
+set yzeroaxis linetype -2 linewidth 1.000
+set zzeroaxis linetype -2 linewidth 1.000
+set x2zeroaxis linetype -2 linewidth 1.000
+set y2zeroaxis linetype -2 linewidth 1.000
+set ticslevel 0.5
+set mxtics default
+set mytics default
+set mztics default
+set mx2tics default
+set my2tics default
+set mcbtics default
+set xtics border in scale 1,0.5 mirror norotate  offset character 0, 0, 0 autojustify
+set xtics autofreq  norangelimit
+set ytics border in scale 1,0.5 mirror norotate  offset character 0, 0, 0 autojustify
+set ytics autofreq  norangelimit
+set ztics border in scale 1,0.5 nomirror norotate  offset character 0, 0, 0 autojustify
+set ztics autofreq  norangelimit
+set nox2tics
+set noy2tics
+set cbtics border in scale 1,0.5 mirror norotate  offset character 0, 0, 0 autojustify
+set cbtics autofreq  norangelimit
+set rtics axis in scale 1,0.5 nomirror norotate  offset character 0, 0, 0 autojustify
+set rtics autofreq  norangelimit
+set title "% of time spent in CPU-spans of X or less" 
+set title  offset character 0, 0, 0 font "" norotate
+set timestamp bottom 
+set timestamp "" 
+set timestamp  offset character 0, 0, 0 font "" norotate
+set rrange [ * : * ] noreverse nowriteback
+set trange [ * : * ] noreverse nowriteback
+set urange [ * : * ] noreverse nowriteback
+set vrange [ * : * ] noreverse nowriteback
+set xlabel "time of day" 
+set xlabel  offset character 0, 0, 0 font "" textcolor lt -1 norotate
+set x2label "" 
+set x2label  offset character 0, 0, 0 font "" textcolor lt -1 norotate
+set xrange [ * : * ] noreverse nowriteback
+set x2range [ * : * ] noreverse nowriteback
+set ylabel "%" 
+set ylabel  offset character 0, 0, 0 font "" textcolor lt -1 rotate by -270
+set y2label "" 
+set y2label  offset character 0, 0, 0 font "" textcolor lt -1 rotate by -270
+set yrange [ * : * ] noreverse nowriteback
+set y2range [ * : * ] noreverse nowriteback
+set zlabel "" 
+set zlabel  offset character 0, 0, 0 font "" textcolor lt -1 norotate
+set zrange [ * : * ] noreverse nowriteback
+set cblabel "" 
+set cblabel  offset character 0, 0, 0 font "" textcolor lt -1 rotate by -270
+set cbrange [ * : * ] noreverse nowriteback
+set zero 1e-08
+set lmargin  -1
+set bmargin  -1
+set rmargin  -1
+set tmargin  -1
+set locale "en_US.UTF-8"
+set pm3d explicit at s
+set pm3d scansautomatic
+set pm3d interpolate 1,1 flush begin noftriangles nohidden3d corners2color mean
+set palette positive nops_allcF maxcolors 0 gamma 1.5 color model RGB 
+set palette rgbformulae 7, 5, 15
+set colorbox default
+set colorbox vertical origin screen 0.9, 0.2, 0 size screen 0.05, 0.6, 0 front bdefault
+set style boxplot candles range  1.50 outliers pt 7 separation 1 labels auto unsorted
+set loadpath 
+set fontpath 
+set psdir
+set fit noerrorvariables
+GNUTERM = "wxt"
+plot '/tmp/to_plot' u 1:7 t 'inf' w filledcurves x1, '/tmp/to_plot' u 1:6 t '10' w filledcurves x1, '/tmp/to_plot' u 1:5 t '1' w filledcurves x1, '/tmp/to_plot' u 1:4 t '0.1' w filledcurves x1, '/tmp/to_plot' u 1:3 t '0.01' w filledcurves x1, '/tmp/to_plot' u 1:2 t '0.001' w filledcurves x1
+#    EOF

data/lib/em-monitor.rb

@@ -0,0 +1,202 @@
+require 'lspace/eventmachine'
+
+# EM::Monitor adds a few methods to eventmachine that can help you
+# keep track of 'lag' caused by long-running CPU spans on the reactor thread.
+module EventMachine
+
+  class << self
+    alias_method :run_without_monitor, :run
+    private :run_without_monitor
+  end
+
+  # Run the eventmachine reactor with monitoring.
+  def self.run(*args, &block)
+    run_without_monitor(*args) do |*a, &b|
+      EM::Monitor.new do |monitor|
+        @monitor = monitor
+        block.call(*a, &b) if block_given?
+      end
+    end
+  ensure
+    @monitor = nil
+  end
+
+  # Set the block to be called periodically with timing data.
+  #
+  # @param [Hash] opts  Configuration
+  # @param [Proc] block  the block to call.
+  #
+  # @option opts [Number] :interval (60)
+  #   The approximate number of seconds between calls to your block.
+  #   If your event loop regularly runs long CPU-spans then the actual time between
+  #   calls can vary significantly.
+  #
+  # @yieldparam [Array<Float>] spans  The number of seconds spent by each CPU-span in the
+  #                                   monitoring interval
+  # @yieldparam [Time] from  The start of the monitoring interval
+  # @yieldparam [Time] to    The end of the monitoring interval
+  #
+  # @example
+  #   EM::monitor_spans do |spans, from, to|
+  #     puts "Used %.2f seconds of CPU in the last %.2f seconds." % (spans.inject(&:+), to - from)
+  #   end
+  def self.monitor_spans(opts = {}, &block)
+    raise "EventMachine not initialized" unless @monitor
+    @monitor.monitor_spans(opts[:interval] || Monitor::DEFAULT_INTERVAL, &block)
+  end
+
+  # Set the block to be called periodically with histogram data.
+  #
+  # This is a convenience wrapper around {monitor_spans} for the common use-case of
+  # wanting to plot a histogram of loop utilisation split into time-chunks.
+  #
+  # In the normal case you can plot these values directly and it will tell you
+  # how much CPU-time was used by spans shorter than a given length. However, care
+  # should be taken if CPU-spans are often of similar length to :interval. This can
+  # cause the actual delay between calls to the block to vary significantly and so
+  # if you're trying to plot a line of CPU-utilization then it can give you misleading
+  # answers. If this is a concern to you then you might want to use the :cumulative
+  # mode and ask your graphing library to plot the derivative of the values over time.
+  #
+  # @param [Hash] opts  Configuration for the histogram
+  # @param [Proc] block  the block to call.
+  #
+  # @option opts [Number] :interval (60)
+  #   The approximate number of seconds between calls to your block.
+  #   If your event loop regularly runs long CPU-spans then the actual time between
+  #   calls can vary significantly.
+  #
+  # @option opts [Array<Number>] :buckets ([0.001, 0.01, 0.1, 1, 10, Infinity])
+  #   The boundaries of the histogram buckets, Infinity will be added even if it's not
+  #   specified by you to ensure that all spans are included.
+  #   CPU-spans are put into the smallest bucket with a limit longer than the span.
+  #
+  # @option opts [Boolean] :stacked (false)
+  #   When true larger buckets include the sum of all smaller buckets in addition to
+  #   the number of seconds spent in CPU-spans that fell into that bucket directly.
+  #   When false each CPU-span will be put into exactly one bucket
+  #
+  # @option opts [Boolean] :cumulative (false)
+  #   When true the values of each bucket will increase monotonically and the
+  #   derivative over time can be used to tell how much CPU was used by spans
+  #   in each bucket in the current monitoring interval.
+  #   When false the values of each bucket are only the amount of time spent
+  #   by CPU-spans in that bucket in the current monitoring interval.
+  #
+  # @yieldparam [Hash<Float,Float>] histogram  A histogram from bucket-size to
+  #   amount of CPU-time spent in that bucket.
+  # @yieldparam [Time] from  The start of the monitoring interval
+  # @yieldparam [Time] to    The end of the monitoring interval
+  #
+  # @example
+  #   # Create an input file suitable for feeding to gnuplot.
+  #   #
+  #   EM::monitor_histogram(stacked: true) do |hist, from, to|
+  #     gnuplot_input.puts #{to.iso8601} #{hist.values.join(" ")}"
+  #   end
+  def self.monitor_histogram(opts = {}, &block)
+    stacked    = !!opts[:stacked]
+    cumulative = !!opts[:cumulative]
+    interval   =   opts[:interval] || Monitor::DEFAULT_INTERVAL
+    buckets    =  (opts[:buckets]  || Monitor::DEFAULT_BUCKETS).sort
+    buckets << (1/0.0)
+
+    # ensure the histogram keys are in the right order
+    hist = buckets.each_with_object({}){ |bucket, h| h[bucket] = 0 }
+
+    monitor_spans(opts) do |spans, from, to|
+
+      unless cumulative
+        hist = buckets.each_with_object({}){ |bucket, h| h[bucket] = 0 }
+      end
+
+      if stacked
+        spans.each do |span|
+          buckets.each do |bucket|
+            hist[bucket] += span if bucket > span
+          end
+        end
+      else
+        spans.each do |span|
+          hist[buckets.detect{ |bucket| bucket > span }] += span
+        end
+      end
+
+      block.call hist, from, to
+    end
+  end
+
+  # The monitor object itself deals with maintaining lspace and
+  # timers.
+  class Monitor
+    # How long (by default) between calls to monitors
+    DEFAULT_INTERVAL = 60
+    # Which buckets to include in the histogram by default
+    DEFAULT_BUCKETS = [0.001, 0.01, 0.1, 1, 10]
+
+    # Create a new monitor.
+    #
+    # The block will be called in the monitor's LSpace, all further
+    # EM work should happen within the block to ensure that we measure
+    # everything.
+    #
+    # @param [Proc] block  The block during which to monitor events
+    # @yieldparam [Monitor] self
+    def initialize(&block)
+      create_lspace.enter do
+        block.call self
+      end
+    end
+
+    # Attach a listener to this monitor.
+    #
+    # Only one listener can be active at a time, and the interval set
+    # here will take affect after the next tick of the previous interval.
+    #
+    # @param [Number] interval  The (lower bound of) time in seconds between calls to block
+    # @param [Proc] block  The block to call
+    # @yieldparam [Array<Float>] spans  Each number of seconds the event loop spent processing.
+    # @yieldparam [Time] from  The time at which the block was previously called
+    # @yieldparam [Time] to  The current time
+    # @see EM.monitor_spans
+    def monitor_spans(interval, &block)
+      @periodic_timer ||= create_timer(interval)
+      @periodic_timer.interval = interval
+      @monitor = block
+    end
+
+    private
+
+    # Add an around_filter to LSpace that wraps every CPU-span in a timing function.
+    #
+    # @return [LSpace]
+    def create_lspace
+      LSpace.new.around_filter do |&block|
+        start = Time.now
+        begin
+          block.call
+        ensure
+          @timings << Time.now - start if @timings
+        end
+      end
+    end
+
+    # Add a periodic timer that will periodically call @monitor with the contents
+    # of @timings.
+    #
+    # @param [Number] interval  The interval to use for the timer.
+    # @return [EM::PeriodicTimer]
+    def create_timer(interval)
+      @timings = []
+      time = Time.now
+      EM::PeriodicTimer.new(interval) do
+        # Set last_time to *before* we call the monitor.
+        # This is because the duration of the monitor will be included in the next set of
+        # timings.
+        last_time, time = time, Time.now
+        timings = @timings.slice!(0..-1)
+        @monitor.call timings, last_time, time
+      end
+    end
+  end
+end

data/test/test_em-monitor.rb

@@ -0,0 +1,232 @@
+$: << './lib'
+require 'em-monitor'
+require 'minitest/autorun'
+require 'pry'
+
+class TestEmMonitor < MiniTest::Unit::TestCase
+
+  def test_before_running
+    e = assert_raises(RuntimeError){ EM::monitor_spans }
+    assert_equal "EventMachine not initialized", e.message
+  end
+
+  def test_monitor_spans
+    spans = from = to = nil
+
+    EM::run do
+      EM::monitor_spans(interval: 0.1) do |*a|
+        spans, from, to = a
+        EM::stop
+      end
+      10.times do
+        EM::next_tick{ sleep 0.005 }
+      end
+      sleep 0.05
+    end
+
+    assert_equal spans.size, 11
+    assert_in_delta spans.first, 0.05
+
+    spans.drop(1).each do |span|
+      assert_in_delta span, 0.005
+    end
+
+    assert_in_delta(to - from, 0.1, 0.002)
+  end
+
+  def test_span_raising_exception
+    spans = from = to = nil
+    EM::run do
+      EM::monitor_spans(interval: 0.1) do |*a|
+        spans, from, to = a
+        EM::stop
+      end
+      EM::error_handler do
+        sleep 0.006
+      end
+
+      EM::next_tick do
+        sleep 0.004
+        raise "oops"
+      end
+
+      sleep 0.002
+    end
+
+    assert_in_delta spans[0], 0.002
+    assert_in_delta spans[1], 0.004
+    assert_in_delta spans[2], 0.006
+  end
+
+  def test_monitor_histograms
+    histogram = from = to = nil
+
+    EM::run do
+      EM::monitor_histogram(interval: 0.6,  buckets: [0.01, 0.02, 0.03, 0.04]) do |*a|
+        histogram, from, to = a
+        EM::stop
+      end
+      4.times do |i|
+        EM::next_tick{
+          5.times do
+            EM::next_tick{ sleep(0.005 + i * 0.01) }
+          end
+        }
+      end
+      sleep 0.055
+    end
+
+    assert_equal histogram.keys, [0.01, 0.02, 0.03, 0.04, 1/0.0]
+
+    assert_in_delta histogram[0.01], 0.025
+    assert_in_delta histogram[0.02], 0.075
+    assert_in_delta histogram[0.03], 0.125
+    assert_in_delta histogram[0.04], 0.175
+    assert_in_delta histogram[1 / 0.0], 0.055
+    assert_in_delta(to - from, 0.6, 0.002)
+  end
+
+  def test_stacked_histogram
+    histogram = from = to = nil
+
+    EM::run do
+      EM::monitor_histogram(interval: 0.5,  buckets: [0.01, 0.02, 0.03, 0.04], stacked: true) do |*a|
+        histogram, from, to = a
+        EM::stop
+      end
+      4.times do |i|
+        EM::next_tick{
+          5.times do
+            EM::next_tick{ sleep(0.005 + i * 0.01) }
+          end
+        }
+      end
+      sleep 0.055
+    end
+
+    assert_equal histogram.keys, [0.01, 0.02, 0.03, 0.04, 1/0.0]
+
+    assert_in_delta histogram[0.01], 0.025, 0.01
+    assert_in_delta histogram[0.02], 0.100, 0.01
+    assert_in_delta histogram[0.03], 0.225, 0.01
+    assert_in_delta histogram[0.04], 0.400, 0.01
+    assert_in_delta histogram[1 / 0.0], 0.455, 0.01
+    assert_in_delta(to - from, 0.5, 0.02)
+  end
+
+  def test_cumulative_histogram
+    histogram = from = to = nil
+    histogram2 = from2 = to2 = nil
+    second_time = false
+
+    EM::run do
+      trigger = lambda do
+        4.times do |i|
+          EM::next_tick{
+            5.times do
+              EM::next_tick{ sleep(0.005 + i * 0.01) }
+            end
+          }
+        end
+      end
+      EM::monitor_histogram(interval: 0.5,  buckets: [0.01, 0.02, 0.03, 0.04], cumulative: true) do |*a|
+        if second_time
+          histogram2, from2, to2 = a
+          EM::stop
+        else
+          histogram, from, to = a
+          histogram = histogram.dup
+          second_time = true
+          trigger.()
+          sleep 0.066
+        end
+      end
+      trigger.()
+      sleep 0.055
+    end
+
+    assert_equal histogram.keys, [0.01, 0.02, 0.03, 0.04, 1/0.0]
+
+    assert_in_delta histogram[0.01], 0.025, 0.01
+    assert_in_delta histogram[0.02], 0.075, 0.01
+    assert_in_delta histogram[0.03], 0.125, 0.01
+    assert_in_delta histogram[0.04], 0.175, 0.01
+    assert_in_delta histogram[1 / 0.0], 0.055, 0.01
+    assert_in_delta(to - from, 0.5, 0.02)
+
+    assert_equal to, from2
+
+    assert_in_delta histogram2[0.01], 0.025 * 2, 0.01
+    assert_in_delta histogram2[0.02], 0.075 * 2, 0.01
+    assert_in_delta histogram2[0.03], 0.125 * 2, 0.01
+    assert_in_delta histogram2[0.04], 0.175 * 2, 0.01
+    assert_in_delta histogram2[1 / 0.0], 0.055 + 0.066, 0.01
+    assert_in_delta(to2 - from2, 0.566, 0.01)
+  end
+
+  def test_cumulative_stacked_histogram
+    histogram = from = to = nil
+    histogram2 = from2 = to2 = nil
+    second_time = false
+
+    EM::run do
+      trigger = lambda do
+        4.times do |i|
+          EM::next_tick{
+            5.times do
+              EM::next_tick{ sleep(0.005 + i * 0.01) }
+            end
+          }
+        end
+      end
+      EM::monitor_histogram(interval: 0.5,  buckets: [0.01, 0.02, 0.03, 0.04], cumulative: true, stacked: true) do |*a|
+        if second_time
+          histogram2, from2, to2 = a
+          EM::stop
+        else
+          histogram, from, to = a
+          histogram = histogram.dup
+          second_time = true
+          trigger.()
+          sleep 0.066
+        end
+      end
+      trigger.()
+      sleep 0.055
+    end
+
+    assert_equal histogram.keys, [0.01, 0.02, 0.03, 0.04, 1/0.0]
+
+    assert_in_delta histogram[0.01], 0.025, 0.01
+    assert_in_delta histogram[0.02], 0.100, 0.01
+    assert_in_delta histogram[0.03], 0.225, 0.01
+    assert_in_delta histogram[0.04], 0.400, 0.01
+    assert_in_delta histogram[1 / 0.0], 0.455, 0.01
+    assert_in_delta(to - from, 0.5, 0.02)
+
+    assert_equal to, from2
+
+    assert_in_delta histogram2[0.01], 0.025 * 2, 0.01
+    assert_in_delta histogram2[0.02], 0.100 * 2, 0.01
+    assert_in_delta histogram2[0.03], 0.225 * 2, 0.01
+    assert_in_delta histogram2[0.04], 0.400 * 2, 0.01
+    assert_in_delta histogram2[1 / 0.0], 0.455 + 0.466, 0.01
+    assert_in_delta(to2 - from2, 0.566, 0.01)
+  end
+
+  def test_span_longer_than_interval
+    spans = from = to = nil
+
+    EM::run do
+      EM::monitor_spans(interval: 0.001) do |*a|
+        spans, from, to = a
+        EM::stop
+      end
+      EM::next_tick{ sleep 0.005 }
+    end
+
+    assert_equal spans.size, 2
+    assert_in_delta(spans.last, 0.005)
+    assert_in_delta(to - from, 0.005, 0.002)
+  end
+end

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification
+name: em-monitor
+version: !ruby/object:Gem::Version
+  prerelease: 
+  version: '0.1'
+platform: ruby
+authors:
+- Conrad Irwin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-02-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  type: :runtime
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: eventmachine
+- !ruby/object:Gem::Dependency
+  type: :runtime
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: lspace
+description: ! "EventLoops are awesome unless you're doing a lot of blocking CPU stuff,
+  at which point they become useless.\n                     This gem lets you easily
+  graph the lengths of CPU-blocked spans so that you can take action to make your\n
+  \                    eventmachine server faster"
+email:
+- conrad@rapportive.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Rakefile
+- em-monitor.gemspec
+- example/gnuplot.rb
+- example/stacked.plot
+- lib/em-monitor.rb
+- test/test_em-monitor.rb
+homepage: http://github.com/ConradIrwin/em-monitor
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Monitor the distribution of your eventmachine CPU usage
+test_files: []
+has_rdoc: