oneapm_rpm 1.1.0

data/lib/one_apm/support/system_info.rb

@@ -0,0 +1,211 @@
+# encoding: utf-8
+
+# This module is intended to provide access to information about the host OS and
+# [virtual] machine. It intentionally does no caching and maintains no state -
+# caching should be handled by clients if needed. Methods should return nil if
+# the requested information is unavailable.
+
+require 'rbconfig'
+
+module OneApm
+  module Agent
+    module SystemInfo
+      def self.ruby_os_identifier
+        RbConfig::CONFIG['target_os']
+      end
+
+      def self.clear_processor_info
+        @processor_info = nil
+      end
+
+      def self.get_processor_info
+        if @processor_info.nil?
+          case ruby_os_identifier
+
+          when /darwin/
+            @processor_info = {
+              :num_physical_packages  => sysctl_value('hw.packages').to_i,
+              :num_physical_cores     => sysctl_value('hw.physicalcpu_max').to_i,
+              :num_logical_processors => sysctl_value('hw.logicalcpu_max').to_i
+            }
+            # in case those don't work, try backup values
+            if @processor_info[:num_physical_cores] <= 0
+              @processor_info[:num_physical_cores] = sysctl_value('hw.physicalcpu').to_i
+            end
+            if @processor_info[:num_logical_processors] <= 0
+              @processor_info[:num_logical_processors] = sysctl_value('hw.logicalcpu').to_i
+            end
+            if @processor_info[:num_logical_processors] <= 0
+              @processor_info[:num_logical_processors] = sysctl_value('hw.ncpu').to_i
+            end
+
+          when /linux/
+            cpuinfo = proc_try_read('/proc/cpuinfo')
+            @processor_info = cpuinfo ? parse_cpuinfo(cpuinfo) : {}
+
+          when /freebsd/
+            @processor_info = {
+              :num_physical_packages  => nil,
+              :num_physical_cores     => nil,
+              :num_logical_processors => sysctl_value('hw.ncpu').to_i
+            }
+          end
+
+          # give nils for obviously wrong values
+          @processor_info.keys.each do |key|
+            value = @processor_info[key]
+            if value.is_a?(Numeric) && value <= 0
+              @processor_info[key] = nil
+            end
+          end
+        end
+
+        @processor_info
+      rescue
+        {}
+      end
+
+      def self.sysctl_value(name)
+        # make sure to redirect stderr so we don't spew if the name is unknown
+        `sysctl -n #{name} 2>/dev/null`
+      end
+
+      def self.parse_cpuinfo(cpuinfo)
+        # Build a hash of the form
+        #   { [phys_id, core_id] => num_logical_processors_on_this_core }
+        cores = Hash.new(0)
+        phys_id = core_id = nil
+
+        total_processors = 0
+
+        cpuinfo.split("\n").map(&:strip).each do |line|
+          case line
+          when /^processor\s*:/
+            cores[[phys_id, core_id]] += 1 if phys_id && core_id
+            phys_id = core_id = nil # reset these values
+            total_processors += 1
+          when /^physical id\s*:(.*)/
+            phys_id = $1.strip.to_i
+          when /^core id\s*:(.*)/
+            core_id = $1.strip.to_i
+          end
+        end
+        cores[[phys_id, core_id]] += 1 if phys_id && core_id
+
+        num_physical_packages  = cores.keys.map(&:first).uniq.size
+        num_physical_cores     = cores.size
+        num_logical_processors = cores.values.reduce(0,:+)
+
+        if num_physical_cores == 0
+          num_logical_processors = total_processors
+
+          if total_processors == 1
+            # Some older, single-core processors might not list ids,
+            # so we'll just mark them all 1.
+            num_physical_packages = 1
+            num_physical_cores    = 1
+          else
+            # We have no way of knowing how many packages or cores
+            # we have, even though we know how many processors there are.
+            num_physical_packages = nil
+            num_physical_cores    = nil
+          end
+        end
+
+        {
+          :num_physical_packages  => num_physical_packages,
+          :num_physical_cores     => num_physical_cores,
+          :num_logical_processors => num_logical_processors
+        }
+      end
+
+      def self.num_physical_packages ; get_processor_info[:num_physical_packages ] end
+      def self.num_physical_cores    ; get_processor_info[:num_physical_cores    ] end
+      def self.num_logical_processors
+        processor_count = get_processor_info[:num_logical_processors]
+
+        if processor_count.nil?
+          OneApm::Agent.logger.warn("Failed to determine processor count, assuming 1")
+          processor_count = 1
+        end
+
+        processor_count
+      end
+
+      def self.processor_arch
+        RbConfig::CONFIG['target_cpu']
+      end
+
+      def self.os_version
+        proc_try_read('/proc/version')
+      end
+
+      def self.docker_container_id
+        return unless ruby_os_identifier =~ /linux/
+
+        cgroup_info = proc_try_read('/proc/self/cgroup')
+        return unless cgroup_info
+
+        parse_docker_container_id(cgroup_info)
+      end
+
+      def self.parse_docker_container_id(cgroup_info)
+        cpu_cgroup = parse_cgroup_ids(cgroup_info)['cpu']
+        return unless cpu_cgroup
+
+        case cpu_cgroup
+        # docker native driver w/out systemd (fs)
+        when %r{^/docker/([0-9a-f]+)$}                      then $1
+        # docker native driver with systemd
+        when %r{^/system\.slice/docker-([0-9a-f]+)\.scope$} then $1
+        # docker lxc driver
+        when %r{^/lxc/([0-9a-f]+)$}                         then $1
+        # not in any cgroup
+        when '/'                                            then nil
+        # in a cgroup, but we don't recognize its format
+        else
+          ::OneApm::Agent.logger.debug("Ignoring unrecognized cgroup ID format: '#{cpu_cgroup}'")
+          nil
+        end
+      end
+
+      def self.parse_cgroup_ids(cgroup_info)
+        cgroup_ids = {}
+
+        cgroup_info.split("\n").each do |line|
+          parts = line.split(':')
+          next unless parts.size == 3
+          _, subsystems, cgroup_id = parts
+          subsystems = subsystems.split(',')
+          subsystems.each do |subsystem|
+            cgroup_ids[subsystem] = cgroup_id
+          end
+        end
+
+        cgroup_ids
+      end
+
+      # A File.read against /(proc|sysfs)/* can hang with some older Linuxes.
+      # See https://bugzilla.redhat.com/show_bug.cgi?id=604887, RUBY-736, and
+      # https://github.com/opscode/ohai/commit/518d56a6cb7d021b47ed3d691ecf7fba7f74a6a7
+      # for details on why we do it this way.
+      def self.proc_try_read(path)
+        return nil unless File.exist?(path)
+        content = ''
+        File.open(path) do |f|
+          loop do
+            begin
+              content << f.read_nonblock(4096)
+            rescue EOFError
+              break
+            rescue Errno::EWOULDBLOCK, Errno::EAGAIN
+              content = nil
+              break # don't select file handle, just give up
+            end
+          end
+        end
+        content
+      end
+    end
+  end
+end

data/lib/one_apm/support/timer_lib.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+# Copyright:  (C) 2008 David Vollbracht & Philippe Hanrigou
+
+# This code was borrowed from the system_timer gem under the terms
+# of the Ruby license.  It has been slightly modified.
+
+# Defines the constant TimerLib to the appropriate timeout library
+module OneApm
+
+  begin
+    # Try to use the SystemTimer gem instead of Ruby's timeout library
+    # when running on Ruby 1.8.x. See:
+    #   http://ph7spot.com/articles/system_timer
+    # We don't want to bother trying to load SystemTimer on jruby,
+    # ruby 1.9+ and rbx.
+    if !defined?(RUBY_ENGINE) || (RUBY_ENGINE == 'ruby' && RUBY_VERSION < '1.9.0')
+      require 'system_timer'
+      TimerLib = SystemTimer
+    else
+      require 'timeout'
+      TimerLib = Timeout
+    end
+  rescue LoadError
+    require 'timeout'
+    TimerLib = Timeout
+  end
+
+end

data/lib/one_apm/support/version_number.rb

@@ -0,0 +1,51 @@
+# encoding: utf-8
+
+module OneApm
+  class VersionNumber
+    include Comparable
+
+    attr_reader :parts
+
+    def initialize(version_string)
+      version_string ||= '1.0.0'
+      @parts = version_string.split('.').map{|n| n =~ /^\d+$/ ? n.to_i : n}
+    end
+
+    def major_version; @parts[0]; end
+    def minor_version; @parts[1]; end
+    def tiny_version;  @parts[2]; end
+
+    def <=>(other)
+      other = self.class.new(other) if other.is_a? String
+      self.class.compare(self.parts, other.parts)
+    end
+
+    def to_s
+      @parts.join(".")
+    end
+
+    def hash
+      @parts.hash
+    end
+
+    def eql? other
+      (self <=> other) == 0
+    end
+
+    private
+
+    def self.compare(parts1, parts2)
+      a, b = parts1.first, parts2.first
+      case
+        when a.nil? && b.nil? then 0
+        when a.nil? then b.is_a?(Fixnum) ?  -1 : 1
+        when b.nil? then -compare(parts2, parts1)
+        when a.to_s == b.to_s then compare(parts1[1..-1], parts2[1..-1])
+        when a.is_a?(String) then b.is_a?(Fixnum) ?  -1 : (a <=> b)
+        when b.is_a?(String) then -compare(parts2, parts1)
+        else # they are both fixnums, not nil
+          a <=> b
+      end
+    end
+  end
+end

data/lib/one_apm/support/vm.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+
+require 'one_apm/support/language_support'
+require 'one_apm/support/vm/mri_vm'
+require 'one_apm/support/vm/jruby_vm'
+require 'one_apm/support/vm/rubinius_vm'
+
+module OneApm
+  module Support
+    module VM
+      def self.snapshot
+        vm.snapshot
+      end
+
+      def self.vm
+        @vm ||= create_vm
+      end
+
+      def self.create_vm
+        if OneApm::LanguageSupport.using_engine?('jruby')
+          JRubyVM.new
+        elsif OneApm::LanguageSupport.using_engine?('rbx')
+          RubiniusVM.new
+        else
+          MriVM.new
+        end
+      end
+    end
+  end
+end

data/lib/one_apm/support/vm/jruby_vm.rb

@@ -0,0 +1,38 @@
+# encoding: utf-8
+
+require 'thread'
+require 'one_apm/support/vm/snapshot'
+
+module OneApm
+  module Support
+    module VM
+      class JRubyVM
+        def snapshot
+          snap = Snapshot.new
+          gather_stats(snap)
+          snap
+        end
+
+        def gather_stats(snap)
+          if supports?(:gc_runs)
+            gc_stats = GC.stat
+            snap.gc_runs = gc_stats[:count]
+          end
+
+          snap.thread_count = Thread.list.size
+        end
+
+        def supports?(key)
+          case key
+          when :gc_runs
+            RUBY_VERSION >= "1.9.2"
+          when :thread_count
+            true
+          else
+            false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/one_apm/support/vm/monotonic_gc_profiler.rb

@@ -0,0 +1,43 @@
+# encoding: utf-8
+
+# The GC::Profiler class available on MRI has to be reset periodically to avoid
+# memory "leaking" in the underlying implementation. However, it's a major
+# bummer for how we want to gather those statistics.
+#
+# This class comes to the rescue. It relies on being the only party to reset
+# the underlying GC::Profiler, but otherwise gives us a steadily increasing
+# total time.
+
+module OneApm
+  module Support
+    module VM
+      class MonotonicGCProfiler
+        def initialize
+          @total_time_s = 0
+          @lock         = Mutex.new
+        end
+
+        def total_time_s
+          if OneApm::LanguageSupport.gc_profiler_enabled?
+            # There's a race here if the next two lines don't execute as an atomic
+            # unit - we may end up double-counting some GC time in that scenario.
+            # Locking around them guarantees atomicity of the read/increment/reset
+            # sequence.
+            @lock.synchronize do
+              # The Ruby 1.9.x docs claim that GC::Profiler.total_time returns
+              # a value in milliseconds. They are incorrect - both 1.9.x and 2.x
+              # return values in seconds.
+              @total_time_s += ::GC::Profiler.total_time
+              ::GC::Profiler.clear
+            end
+          else
+            OneApm::Agent.logger.log_once(:warn, :gc_profiler_disabled,
+              "Tried to measure GC time, but GC::Profiler was not enabled.")
+          end
+
+          @total_time_s
+        end
+      end
+    end
+  end
+end

data/lib/one_apm/support/vm/mri_vm.rb

@@ -0,0 +1,85 @@
+# encoding: utf-8
+
+require 'thread'
+require 'one_apm/support/vm/snapshot'
+
+module OneApm
+  module Support
+    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 = OneApm::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
+            OneApm::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