trashed 3.0.1 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: fc92cf23f413c7dbc13b7e974f0ff667050296dd
-  data.tar.gz: 83a9dacf210062f9aec4d1632095989ec20be08b
+SHA1:
+  metadata.gz: 403348c2e748309e00d851be66bd0428116c9961
+  data.tar.gz: ad21d476079f3aa50de9290d2ee338e060df9fd7
 SHA512:
-  metadata.gz: a13685415df07c31c6b3a95afc25ac2b22c18325b8b799c9b3eb4fca7a4bf805bc0c5bf4acb5f787f4a401214b3c79e05f5d5464deb33936cc5488fbe5934d2f
-  data.tar.gz: ad71d73f6ded5cd28c032b54b45ccec80eccbd2cf129c50582740b0d187331fa8af13db2384e26312b4ba8721f37ee11a098c6fa886280e2b03d7e48e3d71ea3
+  metadata.gz: 14c777b0892850a0402d084919b3fabf9932f812f6a41085985ca83ad4cc38d35c495b72ba7bd6cae8fd5de1c366342aa6fc2dfe5103b1f1574e1cb8445ac3de
+  data.tar.gz: d51091fb467bc565d4b4aa854ca509745d8aed287c577aaf1498ca37793a1a6a1d12515fff7a37670ef330c1addf0b6ad784ba7afc40b0165e5612a6fdc380fe

data/lib/trashed/instruments/gctools_oobgc.rb

@@ -0,0 +1,27 @@
+module Trashed
+  module Instruments
+    # Tracks out of band GCs that occurred *since* the last request.
+    class GctoolsOobgc
+      def start(state, timings, gauges)
+        last = state[:persistent][:oobgc] || Hash.new(0)
+
+        current = {
+          :count => GC::OOB.stat(:count),
+          :major => GC::OOB.stat(:major),
+          :minor => GC::OOB.stat(:minor),
+          :sweep => GC::OOB.stat(:sweep) }
+
+        timings.update \
+          :'OOBGC.count'        => current[:count] - last[:count],
+          :'OOBGC.major_count'  => current[:major] - last[:major],
+          :'OOBGC.minor_count'  => current[:minor] - last[:minor],
+          :'OOBGC.sweep_count'  => current[:sweep] - last[:sweep]
+
+        state[:persistent][:oobgc] = current
+      end
+
+      def measure(state, timings, gauges)
+      end
+    end
+  end
+end

data/lib/trashed/instruments/ree_gc.rb

@@ -5,20 +5,22 @@ module Trashed
         GC.enable_stats
       end
 
-      def start(state)
-        state.update \
-          :'Objects.total' => ObjectSpace.allocated_objects,
-          :'GC.count'      => GC.collections,
-          :'GC.elapsed'    => GC.time,
-          :'GC.memory'     => GC.allocated_size
+      def start(state, timings, gauges)
+        state[:ruby18_gc] = {
+          :objects   => ObjectSpace.allocated_objects,
+          :gc_count  => GC.collections,
+          :gc_time   => GC.time,
+          :gc_memory => GC.allocated_size }
       end
 
       def measure(state, timings, gauges)
+        before = state[:ruby18_gc]
+
         timings.update \
-          :'Objects.total' => ObjectSpace.allocated_objects - state[:'Objects.total'],
-          :'GC.count'      => GC.collections - state[:'GC.count'],
-          :'GC.elapsed'    => GC.time - state[:'GC.elapsed'],
-          :'GC.memory'     => GC.allocated_size - state[:'GC.memory']
+          :'GC.count'             => GC.collections - before[:gc_count],
+          :'GC.time'              => GC.time - before[:gc_time],
+          :'GC.memory'            => GC.allocated_size - before[:gc_memory],
+          :'GC.allocated_objects' => ObjectSpace.allocated_objects - before[:objects]
 
         gauges << [ :'Objects.live',  ObjectSpace.live_objects ]
         gauges << [ :'GC.growth',     GC.growth ]

data/lib/trashed/instruments/ruby_gc.rb

@@ -0,0 +1,28 @@
+module Trashed
+  module Instruments
+    class RubyGC
+      def start(state, timings, gauges)
+        state[:ruby_gc] = GC.stat
+      end
+
+      MEASUREMENTS = {
+        :count => :'GC.count',
+        :major_gc_count => :'GC.major_count',
+        :minor_gc_count => :'GC.minor_gc_count',
+        :total_allocated_object => :'GC.allocated_objects',
+        :total_freed_object => :'GC.freed_objects'
+      }
+
+      def measure(state, timings, gauges)
+        gc = GC.stat
+        before = state[:ruby_gc]
+
+        MEASUREMENTS.each do |stat, metric|
+          timings[metric] = gc[stat] - before[stat] if gc.include? stat
+        end
+
+        gauges.concat gc.map { |k, v| [ :"GC.#{k}", v ] }
+      end
+    end
+  end
+end

data/lib/trashed/instruments/ruby_gc_profiler.rb

@@ -5,21 +5,26 @@ module Trashed
         @has_raw_data = GC::Profiler.respond_to?(:raw_data)
       end
 
-      def start(state)
+      # Captures out-of-band GC time and stats.
+      def start(state, timings, gauges)
         GC::Profiler.enable
-        GC::Profiler.clear
+        measure state, timings, gauges, :OOBGC
       end
 
-      def measure(state, timings, gauges)
-        timings[:'GC.time'] = GC::Profiler.total_time
+      # Captures in-band GC time and stats.
+      def measure(state, timings, gauges, captured = :GC)
+        timings[:"#{captured}.time"] ||= GC::Profiler.total_time
 
         if @has_raw_data
+          timings[:"#{captured}.count"] ||= GC::Profiler.raw_data.size
+
+          timings[:'GC.interval'] = GC::Profiler.raw_data.map { |data| data[:GC_INVOKE_TIME] }
+
           GC::Profiler.raw_data.each do |data|
             gauges.concat data.map { |k, v| [ :"GC.Profiler.#{k}", v ] }
           end
         end
 
-        GC::Profiler.disable
         GC::Profiler.clear
       end
     end

data/lib/trashed/instruments/stopwatch.rb

@@ -6,37 +6,47 @@ module Trashed
         @has_cpu_time = timepiece.respond_to?(:cpu)
       end
 
-      def start(state)
-        state[:'Time.wall'] = @timepiece.wall
-        state[:'Time.cpu']  = @timepiece.cpu if @has_cpu_time
+      def start(state, timings, gauges)
+        state[:stopwatch_wall] = @timepiece.wall
+        state[:stopwatch_cpu]  = @timepiece.cpu if @has_cpu_time
       end
 
       def measure(state, timings, gauges)
-        wall_elapsed = @timepiece.wall - state.delete(:'Time.wall')
+        wall_elapsed = @timepiece.wall - state.delete(:stopwatch_wall)
         timings[:'Time.wall'] = wall_elapsed
         if @has_cpu_time
-          cpu_elapsed = @timepiece.cpu - state.delete(:'Time.cpu')
-          timings[:'Time.cpu'] = cpu_elapsed
-          timings[:'Time.idle'] = wall_elapsed - cpu_elapsed
+          cpu_elapsed = @timepiece.cpu - state.delete(:stopwatch_cpu)
+          idle_elapsed = wall_elapsed - cpu_elapsed
+
+          timings[:'Time.cpu']      = cpu_elapsed
+          timings[:'Time.idle']     = idle_elapsed
+
+          if wall_elapsed == 0
+            timings[:'Time.pct.cpu']  = 0
+            timings[:'Time.pct.idle'] = 0
+          else
+            timings[:'Time.pct.cpu']  = 100.0 * cpu_elapsed  / wall_elapsed
+            timings[:'Time.pct.idle'] = 100.0 * idle_elapsed / wall_elapsed
+          end
         end
       end
     end
 
     module Timepiece
       def self.wall
-        (::Time.now.to_f * 1000).to_i
+        ::Time.now.to_f * 1000
       end
 
       # Ruby 2.1+
       if Process.respond_to?(:clock_gettime)
         def self.cpu
-          Process.clock_gettime Process::CLOCK_PROCESS_CPUTIME_ID, :millisecond
+          Process.clock_gettime Process::CLOCK_PROCESS_CPUTIME_ID, :float_millisecond
         end
 
       # ruby-prof installed
       elsif defined? RubyProf::Measure::ProcessTime
         def self.cpu
-          (RubyProf::Measure::Process.measure * 1000).to_i
+          RubyProf::Measure::Process.measure * 1000
         end
       end
     end

data/lib/trashed/meter.rb

@@ -25,7 +25,7 @@ module Trashed
     end
 
     def instrument!(state, timings, gauges)
-      @needs_start.each { |i| i.start state }
+      @needs_start.each { |i| i.start state, timings, gauges }
       yield.tap do
         @instruments.reverse_each { |i| i.measure state, timings, gauges }
       end
@@ -36,7 +36,7 @@ module Trashed
         @name, @probe = name, probe
       end
 
-      def start(state)
+      def start(state, timings, gauges)
         state[@name] = @probe.call
       end
 

data/lib/trashed/rack.rb

@@ -11,7 +11,7 @@ module Trashed
     end
 
     def call(env)
-      env[STATE]   = {}
+      env[STATE]   = { :persistent => persistent_thread_state }
       env[TIMINGS] = {}
       env[GAUGES]  = []
 
@@ -19,6 +19,10 @@ module Trashed
     end
 
     private
+    def persistent_thread_state
+      Thread.current[:trashed_rack_state] ||= {}
+    end
+
     def build_sampled_instrumented_app(app, meters)
       build_sampled_app app, build_instrumented_app(app, meters)
     end

data/lib/trashed/railtie.rb

@@ -6,6 +6,21 @@ module Trashed
   class Railtie < ::Rails::Railtie
     config.trashed = Trashed::Reporter.new
 
+    # Middleware would like to emit tagged logs after Rails::Rack::Logger
+    # pops its tags. Introduce this haxware to stash the tags in the Rack
+    # env so we can reuse them later.
+    class ExposeLoggerTagsToRackEnv
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        @app.call(env).tap do
+          env['trashed.logger.tags'] = Rails.logger.formatter.current_tags.dup
+        end
+      end
+    end
+
     initializer 'trashed' do |app|
       require 'statsd'
 
@@ -13,6 +28,7 @@ module Trashed
       app.config.trashed.logger ||= Rails.logger
 
       app.middleware.insert_after 'Rack::Runtime', Trashed::Rack, app.config.trashed
+      app.middleware.insert_after 'Rails::Rack::Logger', ExposeLoggerTagsToRackEnv
     end
   end
 end

data/lib/trashed/reporter.rb

@@ -32,7 +32,51 @@ module Trashed
 
     def report_logger(env)
       timings = env[Trashed::Rack::TIMINGS]
-      @logger.info "Rack handled in %dms (GC runs: %d)" % timings.values_at(:'Time.wall', :'GC.count')
+      parts = []
+
+      elapsed = '%.2fms' % timings[:'Time.wall']
+      if timings[:'Time.pct.cpu']
+        elapsed << ' (%.1f%% cpu, %.1f%% idle)' % timings.values_at(:'Time.pct.cpu', :'Time.pct.idle').map(&:to_i)
+      end
+      parts << elapsed
+
+      obj = timings[:'GC.allocated_objects'].to_i
+      parts << '%d objects' % obj unless obj.zero?
+
+      if gcs = timings[:'GC.count'].to_i
+        gc = '%d GCs' % gcs
+        unless gcs.zero?
+          if timings.include?(:'GC.major_count')
+            gc << ' (%d major, %d minor)' % timings.values_at(:'GC.major_count', :'GC.minor_count').map(&:to_i)
+          end
+          if timings.include?(:'GC.time')
+            gc << ' took %.2fms' % timings[:'GC.time']
+          end
+        end
+        parts << gc
+      end
+
+      oobgcs = timings[:'OOBGC.count'].to_i
+      if !oobgcs.zero?
+        oobgc = 'Avoided %d OOB GCs' % oobgcs
+        if timings[:'OOBGC.major_count']
+          oobgc << ' (%d major, %d minor, %d sweep)' % timings.values_at(:'OOBGC.major_count', :'OOBGC.minor_count', :'OOBGC.sweep_count').map(&:to_i)
+        end
+        if timings[:'OOBGC.time']
+          oobgc << ' saving %.2fms' % timings[:'OOBGC.time']
+        end
+        parts << oobgc
+      end
+
+      message = "Rack handled in #{parts * '. '}."
+
+      if @logger.respond_to?(:tagged) && env.include?('trashed.logger.tags')
+        @logger.tagged env['trashed.logger.tags'] do
+          @logger.info message
+        end
+      else
+        @logger.info message
+      end
     end
 
     def report_statsd(env)
@@ -44,7 +88,12 @@ module Trashed
 
     def send_to_statsd(statsd, method, measurements, namespace, dimensions)
       measurements.each do |metric, value|
-        if value.is_a? Numeric
+        case value
+        when Array
+          value.each do |v|
+            send_to_statsd statsd, method, { metric => v }, namespace, dimensions
+          end
+        when Numeric
           Array(dimensions || :All).each do |dimension|
             statsd.send method, :"#{namespace}.#{dimension}.#{metric}", value, @sample_rate
           end

data/lib/trashed/resource_usage.rb

@@ -21,20 +21,8 @@ module Trashed
 
     # Ruby 1.9+
     if GC.respond_to?(:stat)
-      case
-      # Ruby 2.1+
-      when GC.stat[:major_gc_count]
-        require 'trashed/instruments/ruby21_gc'
-        meter.instrument Trashed::Instruments::Ruby21GC.new
-      # Ruby 2.0+
-      when GC.stat[:total_allocated_object]
-        require 'trashed/instruments/ruby20_gc'
-        meter.instrument Trashed::Instruments::Ruby20GC.new
-      # Ruby 1.9
-      else
-        require 'trashed/instruments/ruby19_gc'
-        meter.instrument Trashed::Instruments::Ruby19GC.new
-      end
+      require 'trashed/instruments/ruby_gc'
+      meter.instrument Trashed::Instruments::RubyGC.new
     end
 
     # Ruby 1.9+
@@ -42,5 +30,11 @@ module Trashed
       require 'trashed/instruments/ruby_gc_profiler'
       meter.instrument Trashed::Instruments::RubyGCProfiler.new
     end
+
+    # Ruby 2.1+ with https://github.com/tmm1/gctools
+    if defined? GC::OOB
+      require 'trashed/instruments/gctools_oobgc'
+      meter.instrument Trashed::Instruments::GctoolsOobgc.new
+    end
   end
 end

metadata

@@ -1,79 +1,80 @@
 --- !ruby/object:Gem::Specification
 name: trashed
 version: !ruby/object:Gem::Version
-  version: 3.0.1
+  version: 3.1.0
 platform: ruby
 authors:
 - Jeremy Kemper
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-30 00:00:00.000000000 Z
+date: 2014-03-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: statsd-ruby
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.1'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '10.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '10.2'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '5.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '5.3'
-description: 
+description: Each Rack request eats up time, objects, and GC. Report usage to logs
+  and StatsD.
 email: jeremykemper@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ./init.rb
-- ./lib/trashed.rb
-- ./lib/trashed/instruments/object_space_counter.rb
-- ./lib/trashed/instruments/ree_gc.rb
-- ./lib/trashed/instruments/ruby19_gc.rb
-- ./lib/trashed/instruments/ruby20_gc.rb
-- ./lib/trashed/instruments/ruby21_gc.rb
-- ./lib/trashed/instruments/ruby_gc_profiler.rb
-- ./lib/trashed/instruments/stopwatch.rb
-- ./lib/trashed/meter.rb
-- ./lib/trashed/rack.rb
-- ./lib/trashed/railtie.rb
-- ./lib/trashed/reporter.rb
-- ./lib/trashed/resource_usage.rb
+- "./init.rb"
+- "./lib/trashed.rb"
+- "./lib/trashed/instruments/gctools_oobgc.rb"
+- "./lib/trashed/instruments/object_space_counter.rb"
+- "./lib/trashed/instruments/ree_gc.rb"
+- "./lib/trashed/instruments/ruby_gc.rb"
+- "./lib/trashed/instruments/ruby_gc_profiler.rb"
+- "./lib/trashed/instruments/stopwatch.rb"
+- "./lib/trashed/meter.rb"
+- "./lib/trashed/rack.rb"
+- "./lib/trashed/railtie.rb"
+- "./lib/trashed/reporter.rb"
+- "./lib/trashed/resource_usage.rb"
 homepage: https://github.com/basecamp/trashed
-licenses: []
+licenses:
+- MIT
 metadata: {}
 post_install_message: 
 rdoc_options: []
@@ -81,18 +82,18 @@ 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: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.2.0
 signing_key: 
 specification_version: 4
-summary: Report per-request object allocations, GC time, and more to StatsD
+summary: Rack request GC stats => logs + StatsD
 test_files: []

data/lib/trashed/instruments/ruby19_gc.rb

@@ -1,16 +0,0 @@
-module Trashed
-  module Instruments
-    class Ruby19GC
-      def start(state)
-        gc = GC.stat
-        state[:'GC.count'] = gc[:count]
-      end
-
-      def measure(state, timings, gauges)
-        gc = GC.stat
-        timings[:'GC.count'] = gc[:count] - state.delete(:'GC.count')
-        gauges.concat gc.map { |k, v| [ :"GC.#{k}", v ] }
-      end
-    end
-  end
-end

data/lib/trashed/instruments/ruby20_gc.rb

@@ -1,24 +0,0 @@
-module Trashed
-  module Instruments
-    class Ruby20GC
-      def start(state)
-        gc = GC.stat
-        state.update \
-          :'GC.count'             => gc[:count],
-          :'GC.allocated_objects' => gc[:total_allocated_object],
-          :'GC.freed_objects'     => gc[:total_freed_object]
-      end
-
-      def measure(state, timings, gauges)
-        gc = GC.stat
-
-        timings.update \
-          :'GC.count'             => gc[:count] - state.delete(:'GC.count'),
-          :'GC.allocated_objects' => gc[:total_allocated_object] - state.delete(:'GC.allocated_objects'),
-          :'GC.freed_objects'     => gc[:total_freed_object] - state.delete(:'GC.freed_objects')
-
-        gauges.concat gc.map { |k, v| [ :"GC.#{k}", v ] }
-      end
-    end
-  end
-end

data/lib/trashed/instruments/ruby21_gc.rb

@@ -1,28 +0,0 @@
-module Trashed
-  module Instruments
-    class Ruby21GC
-      def start(state)
-        gc = GC.stat
-        state.update \
-          :'GC.count'             => gc[:count],
-          :'GC.major_count'       => gc[:major_gc_count],
-          :'GC.minor_count'       => gc[:minor_gc_count],
-          :'GC.allocated_objects' => gc[:total_allocated_object],
-          :'GC.freed_objects'     => gc[:total_freed_object]
-      end
-
-      def measure(state, timings, gauges)
-        gc = GC.stat
-
-        timings.update \
-          :'GC.count'             => gc[:count] - state.delete(:'GC.count'),
-          :'GC.major_count'       => gc[:major_gc_count] - state.delete(:'GC.major_count'),
-          :'GC.minor_count'       => gc[:minor_gc_count] - state.delete(:'GC.minor_count'),
-          :'GC.allocated_objects' => gc[:total_allocated_object] - state.delete(:'GC.allocated_objects'),
-          :'GC.freed_objects'     => gc[:total_freed_object] - state.delete(:'GC.freed_objects')
-
-        gauges.concat gc.map { |k, v| [ :"GC.#{k}", v ] }
-      end
-    end
-  end
-end