mmtrix_rpm 1.0.0.1

data/lib/mmtrix/agent/vm/mri_vm.rb

@@ -0,0 +1,87 @@
+# encoding: utf-8
+# This file is distributed under Mmtrix's license terms.
+# See https://github.com/mmtrix/rpm/blob/master/LICENSE for complete details.
+
+require 'thread'
+require 'mmtrix/agent/vm/snapshot'
+
+module Mmtrix
+  module Agent
+    module VM
+      class MriVM
+        def snapshot
+          snap = Snapshot.new
+          gather_stats(snap)
+          snap
+        end
+
+        def gather_stats(snap)
+          gather_gc_stats(snap)
+          gather_ruby_vm_stats(snap)
+          gather_thread_stats(snap)
+          gather_gc_time(snap)
+        end
+
+        def gather_gc_stats(snap)
+          if supports?(:gc_runs)
+            snap.gc_runs = GC.count
+          end
+
+          if GC.respond_to?(:stat)
+            gc_stats = GC.stat
+            snap.total_allocated_object = gc_stats[:total_allocated_objects] || gc_stats[:total_allocated_object]
+            snap.major_gc_count = gc_stats[:major_gc_count]
+            snap.minor_gc_count = gc_stats[:minor_gc_count]
+            snap.heap_live = gc_stats[:heap_live_slots] || gc_stats[:heap_live_slot] || gc_stats[:heap_live_num]
+            snap.heap_free = gc_stats[:heap_free_slots] || gc_stats[:heap_free_slot] || gc_stats[:heap_free_num]
+          end
+        end
+
+        def gather_gc_time(snap)
+          if supports?(:gc_total_time)
+            snap.gc_total_time = Mmtrix::Agent.instance.monotonic_gc_profiler.total_time_s
+          end
+        end
+
+        def gather_ruby_vm_stats(snap)
+          if supports?(:method_cache_invalidations)
+            vm_stats = RubyVM.stat
+            snap.method_cache_invalidations = vm_stats[:global_method_state]
+            snap.constant_cache_invalidations = vm_stats[:global_constant_state]
+          end
+        end
+
+        def gather_thread_stats(snap)
+          snap.thread_count = Thread.list.size
+        end
+
+        def supports?(key)
+          case key
+          when :gc_runs
+            RUBY_VERSION >= '1.9.2'
+          when :gc_total_time
+            Mmtrix::LanguageSupport.gc_profiler_enabled?
+          when :total_allocated_object
+            RUBY_VERSION >= '2.0.0'
+          when :major_gc_count
+            RUBY_VERSION >= '2.1.0'
+          when :minor_gc_count
+            RUBY_VERSION >= '2.1.0'
+          when :heap_live
+            RUBY_VERSION >= '1.9.3'
+          when :heap_free
+            RUBY_VERSION >= '1.9.3'
+          when :method_cache_invalidations
+            RUBY_VERSION >= '2.1.0'
+          when :constant_cache_invalidations
+            RUBY_VERSION >= '2.1.0'
+          when :thread_count
+            true
+          else
+            false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mmtrix/agent/vm/rubinius_vm.rb

@@ -0,0 +1,132 @@
+# encoding: utf-8
+# This file is distributed under Mmtrix's license terms.
+# See https://github.com/mmtrix/rpm/blob/master/LICENSE for complete details.
+
+require 'thread'
+
+module Mmtrix
+  module Agent
+    module VM
+      class RubiniusVM
+        def snapshot
+          snap = Snapshot.new
+          gather_stats(snap)
+          snap
+        end
+
+        def gather_stats(snap)
+          gather_gc_stats(snap)
+          gather_thread_stats(snap)
+        end
+
+        def gather_gc_stats(snap)
+          snap.gc_runs = GC.count
+
+          # Rubinius::Metrics is available since Rubinius 2.3
+          if has_metrics?
+            gather_stats_from_metrics(snap)
+          else
+            gather_stats_from_gc_stat(snap)
+          end
+
+          gather_gc_time(snap)
+        end
+
+        # The '+ 0' bits in here are a workaround for a Rubinius bug wherein
+        # Rubinius::Metrics.data returns 0's as Bignums, and these Bignums
+        # cannot be safely subtraced from Fixnums. The + 0  has the effect of
+        # truncating to a Fixnum if possible without loss of precision.
+        # See https://github.com/rubinius/rubinius/issues/3316
+        def gather_stats_from_metrics(snap)
+          snap.major_gc_count = metric(:'gc.immix.count') + 0
+          snap.minor_gc_count = metric(:'gc.young.count') + 0
+
+          snap.heap_live = metric(:'memory.large.objects.current') +
+            metric(:'memory.young.objects.current') +
+            metric(:'memory.immix.objects.current')
+
+          snap.total_allocated_object =
+            metric(:'memory.large.objects.total') +
+            metric(:'memory.young.objects.total') +
+            metric(:'memory.immix.objects.total')
+
+          snap.method_cache_invalidations = metric(:'vm.inline_cache.resets') + 0
+        end
+
+        def gather_stats_from_gc_stat(snap)
+          gc_stats = GC.stat[:gc]
+
+          if gc_stats
+            snap.major_gc_count = gc_stats[:full][:count] if gc_stats[:full]
+            snap.minor_gc_count = gc_stats[:young][:count] if gc_stats[:young]
+          end
+        end
+
+        def gather_gc_time(snap)
+          if GC.respond_to?(:time)
+            # On Rubinius GC.time returns a time in miliseconds, not seconds.
+            snap.gc_total_time = GC.time / 1000
+          end
+        end
+
+        def gather_thread_stats(snap)
+          snap.thread_count = Thread.list.size
+        end
+
+        def has_metrics?
+          Rubinius.const_defined?(:Metrics)
+        end
+
+        def metric(key)
+          Rubinius::Metrics.data[key]
+        end
+
+        SUPPORTED_KEYS_GC_RBX_METRICS = [
+          :gc_runs,
+          :heap_live,
+          :major_gc_count,
+          :minor_gc_count,
+          :method_cache_invalidations,
+          :thread_count,
+          :total_allocated_object
+        ].freeze
+
+        def supports?(key)
+          if has_metrics?
+            case key
+            when :major_gc_count
+              true
+            when :minor_gc_count
+              true
+            when :heap_live
+              true
+            when :total_allocated_object
+              true
+            when :method_cache_invalidations
+              true
+            when :gc_runs
+              true
+            when :gc_total_time
+              GC.respond_to?(:time)
+            when :thread_count
+              true
+            else
+              false
+            end
+          else
+            case key
+            when :major_gc_count
+              true
+            when :minor_gc_count
+              true
+            when :thread_count
+              true
+            else
+              false
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mmtrix/agent/vm/snapshot.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+# This file is distributed under Mmtrix's license terms.
+# See https://github.com/mmtrix/rpm/blob/master/LICENSE for complete details.
+
+module Mmtrix
+  module Agent
+    module VM
+      class Snapshot
+        attr_accessor :gc_total_time, :gc_runs, :major_gc_count, :minor_gc_count,
+                      :total_allocated_object, :heap_live, :heap_free,
+                      :method_cache_invalidations, :constant_cache_invalidations,
+                      :thread_count, :taken_at
+
+        def initialize
+          @taken_at = Time.now.to_f
+        end
+      end
+    end
+  end
+end

data/lib/mmtrix/agent/vm.rb

@@ -0,0 +1,32 @@
+# encoding: utf-8
+# This file is distributed under Mmtrix's license terms.
+# See https://github.com/mmtrix/rpm/blob/master/LICENSE for complete details.
+
+require 'mmtrix/language_support'
+require 'mmtrix/agent/vm/mri_vm'
+require 'mmtrix/agent/vm/jruby_vm'
+require 'mmtrix/agent/vm/rubinius_vm'
+
+module Mmtrix
+  module Agent
+    module VM
+      def self.snapshot
+        vm.snapshot
+      end
+
+      def self.vm
+        @vm ||= create_vm
+      end
+
+      def self.create_vm
+        if Mmtrix::LanguageSupport.using_engine?('jruby')
+          JRubyVM.new
+        elsif Mmtrix::LanguageSupport.using_engine?('rbx')
+          RubiniusVM.new
+        else
+          MriVM.new
+        end
+      end
+    end
+  end
+end

data/lib/mmtrix/agent/worker_loop.rb

@@ -0,0 +1,98 @@
+# encoding: utf-8
+# This file is distributed under Mmtrix's license terms.
+# See https://github.com/mmtrix/rpm/blob/master/LICENSE for complete details.
+
+require 'thread'
+
+module Mmtrix
+  module Agent
+
+    # A worker loop executes a set of registered tasks on a single thread.
+    # A task is a proc or block with a specified call period in seconds.
+    class WorkerLoop
+
+      attr_accessor :period, :propagate_errors
+      attr_reader :iterations
+
+      # Optional argument :duration (in seconds) for how long the worker loop runs
+      # or :limit (integer) for max number of iterations
+      def initialize(opts={})
+        @should_run = true
+        @next_invocation_time = Time.now
+        @period = 60.0
+        @duration = opts[:duration] if opts[:duration]
+        @limit = opts[:limit] if opts[:limit]
+        @iterations = 0
+        @propagate_errors = opts.fetch(:propagate_errors, false)
+      end
+
+      # Reset state that is changed by running the worker loop
+      def setup(period, task)
+        @task = task
+        @period = period if period
+        @should_run = true
+        @iterations = 0
+
+        now = Time.now
+        @deadline = now + @duration if @duration
+        @next_invocation_time = (now + @period)
+      end
+
+      # Run infinitely, calling the registered tasks at their specified
+      # call periods.  The caller is responsible for creating the thread
+      # that runs this worker loop.  This will run the task immediately.
+      def run(period=nil, &block)
+        setup(period, block)
+        while keep_running? do
+          sleep_time = schedule_next_invocation
+          sleep(sleep_time) if sleep_time > 0
+          run_task if keep_running?
+          @iterations += 1
+        end
+      end
+
+      def schedule_next_invocation
+        now = Time.now
+        while @next_invocation_time <= now && @period > 0
+          @next_invocation_time += @period
+        end
+        @next_invocation_time - Time.now
+      end
+
+      # a simple accessor for @should_run
+      def keep_running?
+        @should_run && under_duration? && under_limit?
+      end
+
+      def under_duration?
+        !@deadline || Time.now < @deadline
+      end
+
+      def under_limit?
+        @limit.nil? || @iterations < @limit
+      end
+
+      # Sets @should_run to false. Returns false
+      def stop
+        @should_run = false
+      end
+
+      # Executes the block given to the worker loop, and handles errors.
+      def run_task
+        if @propagate_errors
+          @task.call
+        else
+          begin
+            @task.call
+          rescue Mmtrix::Agent::ForceRestartException, Mmtrix::Agent::ForceDisconnectException
+            # blow out the loop
+            raise
+          rescue => e
+            # Don't blow out the stack for anything that hasn't already propagated
+            ::Mmtrix::Agent.logger.error "Error running task in Agent Worker Loop:", e
+          end
+        end
+      end
+    end
+  end
+end