barnes 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f7dd4e395ed1fe8dd518e79a0cc8b99029074d2c0eae7c775b198a5e4e142f91
+  data.tar.gz: d1b447e714af1bd2893e24f7d659c641a2bb6481049c636856241dae280b1b21
+SHA512:
+  metadata.gz: 452478b7f41883a87f5564b98dc15bf5ea3fffeed42ed1ebb65ba4e5703aef0e3666c47446ff07edc774619d00e284d8de0b8e6159bfad543cc3dbac485fd6fd
+  data.tar.gz: 7010aec4b79e73221b848519077f220da2d30a8fd29a9de7164c89f72665f251ad9c5b0306d657fb528ef94b7d98e04a505bea6c1e0e4d6f94f33a2572819a39

data/Users/schneems/Documents/projects/barnes/init.rb

@@ -0,0 +1 @@
+require 'barnes'

data/Users/schneems/Documents/projects/barnes/lib/barnes.rb

@@ -0,0 +1,40 @@
+module Barnes
+  DEFAULT_INTERVAL           = 10
+  DEFAULT_AGGREGATION_PERIOD = 60
+  DEFAULT_STATSD             = :default
+  DEFAULT_PANELS             = []
+
+
+  # Starts the reporting client
+  #
+  # Arguments:
+  #
+  #   - interval: How often, in seconds, to instrument and report
+  #   - aggregation_period: The minimal aggregation period in use, in seconds.
+  #   - statsd: The statsd reporter. This should be an instance of statsd-ruby
+  #   - panels: The instrumentation "panels" in use. See `resource_usage.rb` for
+  #     an example panel, which is the default if none are provided.
+  def self.start(interval: DEFAULT_INTERVAL, aggregation_period: DEFAULT_AGGREGATION_PERIOD, statsd: DEFAULT_STATSD, panels: DEFAULT_PANELS)
+    require 'statsd'
+    statsd_client = statsd
+    panels        = panels
+    sample_rate   = interval.to_f / aggregation_period.to_f
+
+    if statsd_client == :default && ENV["PORT"]
+      statsd_client = Statsd.new('127.0.0.1', ENV["PORT"])
+    end
+
+    if statsd_client && statsd_client != :default
+      reporter = Barnes::Reporter.new(statsd: statsd_client, sample_rate: sample_rate)
+
+      unless panels.length > 0
+        panels << Barnes::ResourceUsage.new(sample_rate)
+      end
+
+      Periodic.new reporter: reporter, sample_rate: sample_rate, panels: panels
+    end
+  end
+end
+
+require 'barnes/periodic'
+require 'barnes/railtie' if defined? ::Rails::Railtie

data/Users/schneems/Documents/projects/barnes/lib/barnes/consts.rb

@@ -0,0 +1,3 @@
+module Barnes
+  STATE, COUNTERS, GAUGES = 'barnes.state', 'barnes.counters', 'barnes.gauges'
+end

data/Users/schneems/Documents/projects/barnes/lib/barnes/instruments/gctools_oobgc.rb

@@ -0,0 +1,30 @@
+module Barnes
+  module Instruments
+    # Tracks out of band GCs that occurred *since* the last request.
+    class GctoolsOobgc
+      def start!(state)
+        state[:oobgc] = current
+      end
+
+      def instrument!(state, counters, gauges)
+        last = state[:oobgc]
+        cur = state[:oobgc] = current
+
+        counters.update \
+          :'OOBGC.count'        => cur[:count] - last[:count],
+          :'OOBGC.major_count'  => cur[:major] - last[:major],
+          :'OOBGC.minor_count'  => cur[:minor] - last[:minor],
+          :'OOBGC.sweep_count'  => cur[:sweep] - last[:sweep]
+      end
+
+      private def current
+        {
+          :count => GC::OOB.stat(:count).to_i,
+          :major => GC::OOB.stat(:major).to_i,
+          :minor => GC::OOB.stat(:minor).to_i,
+          :sweep => GC::OOB.stat(:sweep).to_i
+        }
+      end
+    end
+  end
+end

data/Users/schneems/Documents/projects/barnes/lib/barnes/instruments/object_space_counter.rb

@@ -0,0 +1,11 @@
+module Barnes
+  module Instruments
+    class ObjectSpaceCounter
+      def instrument!(state, counters, gauges)
+        ObjectSpace.count_objects.each do |type, count|
+          gauges[:"Objects.#{type}"] = count
+        end
+      end
+    end
+  end
+end

data/Users/schneems/Documents/projects/barnes/lib/barnes/instruments/ree_gc.rb

@@ -0,0 +1,36 @@
+module Barnes
+  module Instruments
+    class Ruby18GC
+      def initialize
+        GC.enable_stats
+      end
+
+      def start!(state)
+        state[:ruby18_gc] = current
+      end
+
+      def instrument!(state, counters, gauges)
+        last = state[:ruby18_gc]
+        cur = state[:ruby18_gc] = current
+
+        counters.update \
+          :'GC.count'             => cur[:gc_count] - before[:gc_count],
+          :'GC.time'              => cur[:gc_time] - before[:gc_time],
+          :'GC.memory'            => cur[:gc_memory] - before[:gc_memory],
+          :'GC.allocated_objects' => cur[:objects] - before[:objects]
+
+        gauges[:'Objects.live'] = ObjectSpace.live_objects
+        gauges[:'GC.growth'] = GC.growth
+      end
+
+      private def current
+        {
+          :objects   => ObjectSpace.allocated_objects,
+          :gc_count  => GC.collections,
+          :gc_time   => GC.time,
+          :gc_memory => GC.allocated_size
+        }
+      end
+    end
+  end
+end

data/Users/schneems/Documents/projects/barnes/lib/barnes/instruments/ruby_gc.rb

@@ -0,0 +1,87 @@
+# A note on GAUGE_COUNTERS.
+#
+# The sample_rate argument allows for the parameterization
+# of instruments that decide to report data as gauges, that
+# would typically be reported as counters.
+#
+# Aggregating counters is typically done simply with the `+`
+# operator, which doesn't preserve the number of unique
+# reporters that contributed to the count, or allow for one
+# to learn the *average* of the counts posted.
+#
+# A gauge is typically aggregated by simply *replacing* the
+# previous value, however, some systems do *more* with gauges
+# when aggregating across multiple sources of that gauge, like,
+# average, or compute stdev.
+#
+# This is problematic, however, when a gauge is being used as
+# a counter, to preserve the average / stdev computational
+# properties from above, because the interval that the gauge
+# is being read it, affects the derivative of the increasing
+# count. Instead of the derivative over 60s, the derivative is
+# taken every 10s, giving us a derivative value that's approximately
+# 1/6th of the actual derivative over 60s.
+#
+# We compensate for this by allowing Instruments to correct for
+# this, and ensure that, even though it's an estimate, the data
+# is scaled appropriately to the target aggregation interval, not
+# just the collection interval.
+
+module Barnes
+  module Instruments
+    class RubyGC
+      COUNTERS = {
+        :count => :'GC.count',
+        :major_gc_count => :'GC.major_count',
+        :minor_gc_count => :'GC.minor_gc_count' }
+
+      GAUGE_COUNTERS = {}
+
+      # Detect Ruby 2.1 vs 2.2 GC.stat naming
+      begin
+        GC.stat :total_allocated_objects
+      rescue ArgumentError
+        GAUGE_COUNTERS.update \
+          :total_allocated_object => :'GC.total_allocated_objects',
+          :total_freed_object => :'GC.total_freed_objects'
+      else
+        GAUGE_COUNTERS.update \
+          :total_allocated_objects => :'GC.total_allocated_objects',
+          :total_freed_objects => :'GC.total_freed_objects'
+      end
+
+      def initialize(sample_rate)
+        # see header for an explanation of how this sample_rate is used
+        @sample_rate = sample_rate
+      end
+
+      def start!(state)
+        state[:ruby_gc] = GC.stat
+      end
+
+      def instrument!(state, counters, gauges)
+        last = state[:ruby_gc]
+        cur = state[:ruby_gc] = GC.stat
+
+        COUNTERS.each do |stat, metric|
+          counters[metric] = cur[stat] - last[stat] if cur.include? stat
+        end
+
+        # special treatment gauges
+        GAUGE_COUNTERS.each do |stat, metric|
+          if cur.include? stat
+            val = cur[stat] - last[stat] if cur.include? stat
+            gauges[metric] = val * (1/@sample_rate)
+          end
+        end
+
+        # the rest of the gauges
+        cur.each do |k, v|
+          unless GAUGE_COUNTERS.include? k
+            gauges[:"GC.#{k}"] = v
+          end
+        end
+      end
+    end
+  end
+end

data/Users/schneems/Documents/projects/barnes/lib/barnes/instruments/stopwatch.rb

@@ -0,0 +1,65 @@
+module Barnes
+  module Instruments
+    class Stopwatch
+      def initialize(timepiece = Timepiece)
+        @timepiece = timepiece
+        @has_cpu_time = timepiece.respond_to?(:cpu)
+      end
+
+      def start!(state)
+        state[:stopwatch] = current
+      end
+
+      def instrument!(state, counters, gauges)
+        last = state[:stopwatch]
+        wall_elapsed = @timepiece.wall - last[:wall]
+        counters[:'Time.wall'] = wall_elapsed
+
+        if @has_cpu_time
+          cpu_elapsed = @timepiece.cpu - last[:cpu]
+          idle_elapsed = wall_elapsed - cpu_elapsed
+
+          counters[:'Time.cpu']      = cpu_elapsed
+          counters[:'Time.idle']     = idle_elapsed
+
+          if wall_elapsed == 0
+            counters[:'Time.pct.cpu']  = 0
+            counters[:'Time.pct.idle'] = 0
+          else
+            counters[:'Time.pct.cpu']  = 100.0 * cpu_elapsed  / wall_elapsed
+            counters[:'Time.pct.idle'] = 100.0 * idle_elapsed / wall_elapsed
+          end
+        end
+
+        state[:stopwatch] = current
+      end
+
+      private def current
+        state = {
+          :wall => @timepiece.wall,
+        }
+        state[:cpu]  = @timepiece.cpu if @has_cpu_time
+        state
+      end
+    end
+
+    module Timepiece
+      def self.wall
+        ::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, :float_millisecond
+        end
+
+      # ruby-prof installed
+      elsif defined? RubyProf::Measure::ProcessTime
+        def self.cpu
+          RubyProf::Measure::Process.measure * 1000
+        end
+      end
+    end
+  end
+end

data/Users/schneems/Documents/projects/barnes/lib/barnes/panel.rb

@@ -0,0 +1,27 @@
+module Barnes
+  class Panel
+    def initialize
+      @instruments = []
+    end
+
+    # Add an instrument to the Panel
+    def instrument(instrument)
+      @instruments << instrument
+    end
+
+    # Initialize the state of each instrument in the panel.
+    def start!(state)
+      @instruments.each do |ins|
+        ins.start! state if ins.respond_to?(:start!)
+      end
+    end
+
+    # Read the values of each instrument into counter_readings,
+    # and gauge_readings. May have side effects on all arguments.
+    def instrument!(state, counter_readings, gauge_readings)
+      @instruments.each do |ins|
+        ins.instrument! state, counter_readings, gauge_readings
+      end
+    end
+  end
+end

data/Users/schneems/Documents/projects/barnes/lib/barnes/periodic.rb

@@ -0,0 +1,48 @@
+require 'barnes/consts'
+
+module Barnes
+  # The periodic class is used to send occasional metrics
+  # to a reporting instance of `Barnes::Reporter` at a semi-regular
+  # rate.
+  class Periodic
+    def initialize(reporter:, sample_rate: 1, panels: [])
+      @reporter = reporter
+      @reporter.sample_rate = sample_rate
+
+      # compute interval based on a 60s reporting phase.
+      @interval = sample_rate * 60.0
+      @panels = panels
+
+      @thread = Thread.new {
+        Thread.current[:barnes_state] = {}
+
+        @panels.each do |panel|
+          panel.start! Thread.current[:barnes_state]
+        end
+
+        loop do
+          begin
+            sleep @interval
+
+            # read the current values
+            env = {
+              STATE    => Thread.current[:barnes_state],
+              COUNTERS => {},
+              GAUGES   => {}
+            }
+
+            @panels.each do |panel|
+              panel.instrument! env[STATE], env[COUNTERS], env[GAUGES]
+            end
+            @reporter.report env
+          end
+        end
+      }
+      @thread.abort_on_exception = true
+    end
+
+    def stop
+      @thread.exit
+    end
+  end
+end

data/Users/schneems/Documents/projects/barnes/lib/barnes/railtie.rb

@@ -0,0 +1,26 @@
+require 'rails/railtie'
+require 'barnes/reporter'
+require 'barnes/resource_usage'
+
+module Barnes
+  # Automatically configures barnes to run with
+  # rails 3, 4, and 5. Configuration can be changed
+  # in the application.rb. For example
+  #
+  #   module YourApp
+  #     class Application < Rails::Application
+  #     config.barnes[:interval] = 20
+  #
+  class Railtie < ::Rails::Railtie
+    config.barnes = {
+      interval:           DEFAULT_INTERVAL,
+      aggregation_period: DEFAULT_AGGREGATION_PERIOD,
+      statsd:             DEFAULT_STATSD,
+      panels:             DEFAULT_PANELS,
+    }
+
+    initializer 'barnes' do |app|
+      Barnes.start(config.barnes)
+    end
+  end
+end

data/Users/schneems/Documents/projects/barnes/lib/barnes/reporter.rb

@@ -0,0 +1,40 @@
+module Barnes
+  # The reporter is used to send stats to the server.
+  #
+  # Example:
+  #
+  #   statsd   = Statsd.new('127.0.0.1', "8125")
+  #   reporter = Reporter.new(statsd: , sample_rate: 10)
+  #   reporter.report_statsd('barnes.counters' => {"hello" => 2})
+  class Reporter
+    attr_accessor :statsd, :sample_rate
+
+    def initialize(statsd: , sample_rate:)
+      @statsd      = statsd
+      @sample_rate = sample_rate.to_f
+
+      if @statsd.respond_to?(:easy)
+        @statsd_method = statsd.method(:easy)
+      else
+        @statsd_method = statsd.method(:batch)
+      end
+    end
+
+    def report(env)
+      report_statsd env if @statsd
+    end
+
+    def report_statsd(env)
+      @statsd_method.call do |statsd|
+        env[Barnes::COUNTERS].each do |metric, value|
+          statsd.count(:"Rack.Server.All.#{metric}", value, @sample_rate)
+        end
+
+        # for :gauge, use sample rate of 1, since gauges in statsd have no sampling characteristics.
+        env[Barnes::GAUGES].each do |metric, value|
+          statsd.gauge(:"Rack.Server.All.#{metric}", value, 1.0)
+        end
+      end
+    end
+  end
+end

data/Users/schneems/Documents/projects/barnes/lib/barnes/resource_usage.rb

@@ -0,0 +1,35 @@
+require 'barnes/panel'
+
+module Barnes
+  class ResourceUsage < Panel
+    def initialize(sample_rate)
+      super()
+
+      require 'barnes/instruments/stopwatch'
+      instrument Barnes::Instruments::Stopwatch.new
+
+      if GC.respond_to? :enable_stats
+        require 'barnes/instruments/ree_gc'
+        instrument Barnes::Instruments::Ruby18GC.new
+      end
+
+      # Ruby 1.9+
+      if ObjectSpace.respond_to? :count_objects
+        require 'barnes/instruments/object_space_counter'
+        instrument Barnes::Instruments::ObjectSpaceCounter.new
+      end
+
+      # Ruby 1.9+
+      if GC.respond_to?(:stat)
+        require 'barnes/instruments/ruby_gc'
+        instrument Barnes::Instruments::RubyGC.new(sample_rate)
+      end
+
+      # Ruby 2.1+ with https://github.com/tmm1/gctools
+      if defined? GC::OOB
+        require 'barnes/instruments/gctools_oobgc'
+        instrument Barnes::Instruments::GctoolsOobgc.new
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification
+name: barnes
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- APG
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-10-25 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: '10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10'
+- !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: Report GC usage data to StatsD.
+email: agwozdziewycz@salesforce.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- "/Users/schneems/Documents/projects/barnes/init.rb"
+- "/Users/schneems/Documents/projects/barnes/lib/barnes.rb"
+- "/Users/schneems/Documents/projects/barnes/lib/barnes/consts.rb"
+- "/Users/schneems/Documents/projects/barnes/lib/barnes/instruments/gctools_oobgc.rb"
+- "/Users/schneems/Documents/projects/barnes/lib/barnes/instruments/object_space_counter.rb"
+- "/Users/schneems/Documents/projects/barnes/lib/barnes/instruments/ree_gc.rb"
+- "/Users/schneems/Documents/projects/barnes/lib/barnes/instruments/ruby_gc.rb"
+- "/Users/schneems/Documents/projects/barnes/lib/barnes/instruments/stopwatch.rb"
+- "/Users/schneems/Documents/projects/barnes/lib/barnes/panel.rb"
+- "/Users/schneems/Documents/projects/barnes/lib/barnes/periodic.rb"
+- "/Users/schneems/Documents/projects/barnes/lib/barnes/railtie.rb"
+- "/Users/schneems/Documents/projects/barnes/lib/barnes/reporter.rb"
+- "/Users/schneems/Documents/projects/barnes/lib/barnes/resource_usage.rb"
+homepage: https://github.com/heroku/barnes
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.14
+signing_key: 
+specification_version: 4
+summary: Ruby GC stats => StatsD
+test_files: []