oneapm_rpm 1.1.0

data/lib/one_apm/support/language_support.rb

@@ -0,0 +1,142 @@
+# encoding: utf-8
+
+module OneApm::LanguageSupport
+  extend self
+
+  # need to use syck rather than psych when possible
+  def needs_syck?
+    !OneApm::LanguageSupport.using_engine?('jruby') &&
+         OneApm::LanguageSupport.using_version?('1.9.2')
+  end
+
+  @@forkable = nil
+  def can_fork?
+    # this is expensive to check, so we should only check once
+    return @@forkable if @@forkable != nil
+
+    if Process.respond_to?(:fork)
+      # if this is not 1.9.2 or higher, we have to make sure
+      @@forkable = ::RUBY_VERSION < '1.9.2' ? test_forkability : true
+    else
+      @@forkable = false
+    end
+
+    @@forkable
+  end
+
+  def using_engine?(engine)
+    if defined?(::RUBY_ENGINE)
+      ::RUBY_ENGINE == engine
+    else
+      engine == 'ruby'
+    end
+  end
+
+  def broken_gc?
+    OneApm::LanguageSupport.using_version?('1.8.7') &&
+      RUBY_PATCHLEVEL < 348 &&
+      !OneApm::LanguageSupport.using_engine?('jruby') &&
+      !OneApm::LanguageSupport.using_engine?('rbx')
+  end
+
+  def with_disabled_gc
+    if defined?(::GC) && ::GC.respond_to?(:disable)
+      val = nil
+      begin
+        ::GC.disable
+        val = yield
+      ensure
+        ::GC.enable
+      end
+      val
+    else
+      yield
+    end
+  end
+
+  def with_cautious_gc
+    if broken_gc?
+      with_disabled_gc { yield }
+    else
+      yield
+    end
+  end
+
+  def gc_profiler_usable?
+    if defined?(::GC::Profiler) && !jruby?
+      true
+    else
+      false
+    end
+  end
+
+  def gc_profiler_enabled?
+    if gc_profiler_usable? && ::GC::Profiler.enabled? && !::OneApm::Agent.config[:disable_gc_profiler]
+      true
+    else
+      false
+    end
+  end
+
+  def object_space_usable?
+    if defined?(::JRuby) && JRuby.respond_to?(:runtime)
+      JRuby.runtime.is_object_space_enabled
+    elsif defined?(::ObjectSpace) && !rubinius?
+      true
+    else
+      false
+    end
+  end
+
+  def jruby?
+    defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
+  end
+
+  def rubinius?
+    defined?(RUBY_ENGINE) && RUBY_ENGINE == 'rbx'
+  end
+
+  def ree?
+    defined?(RUBY_DESCRIPTION) && RUBY_DESCRIPTION =~ /Ruby Enterprise Edition/
+  end
+
+  def using_version?(version)
+    numbers = version.split('.')
+    numbers == ::RUBY_VERSION.split('.')[0, numbers.size]
+  end
+
+  def supports_string_encodings?
+    RUBY_VERSION >= '1.9.0'
+  end
+
+  def test_forkability
+    child = Process.fork { exit! }
+    # calling wait here doesn't seem like it should necessary, but it seems to
+    # resolve some weird edge cases with resque forking.
+    Process.wait child
+    true
+  rescue NotImplementedError
+    false
+  end
+
+  def constant_is_defined?(const_name)
+    const_name.to_s.sub(/\A::/,'').split('::').inject(Object) do |namespace, name|
+      begin
+        result = namespace.const_get(name)
+
+        # const_get looks up the inheritence chain, so if it's a class
+        # in the constant make sure we found the one in our namespace.
+        #
+        # Can't help if the constant isn't a class...
+        if result.is_a?(Module)
+          expected_name = "#{namespace}::#{name}".gsub(/^Object::/, "")
+          return false unless expected_name == result.to_s
+        end
+
+        result
+      rescue NameError
+        false
+      end
+    end
+  end
+end

data/lib/one_apm/support/library_detection.rb

@@ -0,0 +1,119 @@
+# encoding: utf-8
+
+module LibraryDetection
+
+  module_function
+
+  @items = []
+
+  def defer(&block)
+    item = Dependent.new
+    item.instance_eval(&block)
+
+    if item.name
+      seen_names = @items.map { |i| i.name }.compact
+      if seen_names.include?(item.name)
+        OneApm::Agent.logger.warn("Refusing to re-register LibraryDetection block with name '#{item.name}'")
+        return @items
+      end
+    end
+
+    @items << item
+  end
+
+  def detect!
+    @items.each do |item|
+      if item.dependencies_satisfied?
+        item.execute
+      end
+    end
+  end
+
+  def dependency_by_name(name)
+    @items.find {|i| i.name == name }
+  end
+
+  def installed?(name)
+    item = dependency_by_name(name)
+    item && item.executed
+  end
+
+  def items
+    @items
+  end
+
+  def items=(new_items)
+    @items = new_items
+  end
+
+  class Dependent
+    attr_reader :executed
+    attr_accessor :name
+    def executed!
+      @executed = true
+    end
+
+    attr_reader :dependencies
+
+    def initialize
+      @dependencies = []
+      @executes = []
+      @name = nil
+    end
+
+    def dependencies_satisfied?
+      !executed and check_dependencies
+    end
+
+    def execute
+      @executes.each do |x|
+        begin
+          x.call
+        rescue => err
+          OneApm::Agent.logger.error( "Error while installing #{self.name} instrumentation:", err )
+          break
+        end
+      end
+    ensure
+      executed!
+    end
+
+    def check_dependencies
+      return false unless allowed_by_config? && dependencies
+
+      dependencies.all? do |dep|
+        begin
+          dep.call
+        rescue => err
+          OneApm::Agent.logger.error( "Error while detecting #{self.name}:", err )
+          false
+        end
+      end
+    end
+
+    def depends_on
+      @dependencies << Proc.new
+    end
+
+    def allowed_by_config?
+      # If we don't have a name, can't check config so allow it
+      return true if self.name.nil?
+
+      key = "disable_#{self.name}".to_sym
+      if (::OneApm::Agent.config[key] == true)
+        ::OneApm::Agent.logger.debug("Not installing #{self.name} instrumentation because of configuration #{key}")
+        false
+      else
+        true
+      end
+    end
+
+    def named(new_name)
+      self.name = new_name
+    end
+
+    def executes
+      @executes << Proc.new
+    end
+  end
+end

data/lib/one_apm/support/local_environment.rb

@@ -0,0 +1,196 @@
+# encoding: utf-8
+
+require 'set'
+require 'one_apm/version'
+
+module OneApm
+  # This class is responsible for determining the 'dispatcher' in use by the
+  # current process. The dispatcher might be a recognized web server such as
+  # unicorn or passenger, a background job processor such as resque or sidekiq,
+  # or nil for unknown.
+  #
+  # Dispatcher detection is best-effort, and serves two purposes:
+  #
+  # 1. For some dispatchers, we need to apply specific workarounds in order for
+  #    the agent to work correctly.
+  # 2. When reading logs, since multiple processes on a given host might write
+  #    into the same log, it's useful to be able to identify what kind of
+  #    process a given PID mapped to.
+  #
+  # Overriding the dispatcher is possible via the ONE_APM_DISPATCHER
+  # environment variable, but this should not generally be necessary unless
+  # you're on a dispatcher that falls into category 1 above, and our detection
+  # logic isn't working correctly.
+  #
+  # If the environment can't be determined, it will be set to nil.
+  #
+  # OneApm::LocalEnvironment should be accessed through OneApm::Probe#env (via the OneApm::Probe singleton).
+  class LocalEnvironment
+    def discovered_dispatcher
+      discover_dispatcher unless @discovered_dispatcher
+      @discovered_dispatcher
+    end
+
+    def initialize
+      # Extend self with any any submodules of LocalEnvironment.  These can override
+      # the discover methods to discover new framworks and dispatchers.
+      OneApm::LocalEnvironment.constants.each do | const |
+        mod = OneApm::LocalEnvironment.const_get const
+        self.extend mod if mod.instance_of? Module
+      end
+
+      discover_dispatcher
+    end
+
+    # Runs through all the objects in ObjectSpace to find the first one that
+    # match the provided class
+    def find_class_in_object_space(klass)
+      if OneApm::LanguageSupport.object_space_usable?
+        ObjectSpace.each_object(klass) do |x|
+          return x
+        end
+      end
+      return nil
+    end
+
+    private
+
+    def discover_dispatcher
+      dispatchers = %w[
+        passenger
+        torquebox
+        trinidad
+        glassfish
+        resque
+        sidekiq
+        delayed_job
+        puma
+        thin
+        mongrel
+        fastcgi
+        rainbows
+        unicorn
+        goliath
+        webrick
+      ]
+      while dispatchers.any? && @discovered_dispatcher.nil?
+        send 'check_for_'+(dispatchers.shift)
+      end
+    end
+
+    def check_for_torquebox
+      return unless defined?(::JRuby) &&
+         ( org.torquebox::TorqueBox rescue nil)
+      @discovered_dispatcher = :torquebox
+    end
+
+    def check_for_glassfish
+      return unless defined?(::JRuby) &&
+        (((com.sun.grizzly.jruby.rack.DefaultRackApplicationFactory rescue nil) &&
+          defined?(com::sun::grizzly::jruby::rack::DefaultRackApplicationFactory)) ||
+         (jruby_rack? && defined?(::GlassFish::Server)))
+      @discovered_dispatcher = :glassfish
+    end
+
+    def check_for_trinidad
+      return unless defined?(::JRuby) && jruby_rack? && defined?(::Trinidad::Server)
+      @discovered_dispatcher = :trinidad
+    end
+
+    def jruby_rack?
+      defined?(JRuby::Rack::VERSION)
+    end
+
+    def check_for_webrick
+      return unless defined?(::WEBrick) && defined?(::WEBrick::VERSION)
+      @discovered_dispatcher = :webrick
+    end
+
+    def check_for_fastcgi
+      return unless defined?(::FCGI)
+      @discovered_dispatcher = :fastcgi
+    end
+
+    # this case covers starting by mongrel_rails
+    def check_for_mongrel
+      return unless defined?(::Mongrel) && defined?(::Mongrel::HttpServer)
+      @discovered_dispatcher = :mongrel
+    end
+
+    def check_for_unicorn
+      if (defined?(::Unicorn) && defined?(::Unicorn::HttpServer)) && OneApm::LanguageSupport.object_space_usable?
+        v = find_class_in_object_space(::Unicorn::HttpServer)
+        @discovered_dispatcher = :unicorn if v
+      end
+    end
+
+    def check_for_rainbows
+      if (defined?(::Rainbows) && defined?(::Rainbows::HttpServer)) && OneApm::LanguageSupport.object_space_usable?
+        v = find_class_in_object_space(::Rainbows::HttpServer)
+        @discovered_dispatcher = :rainbows if v
+      end
+    end
+
+    def check_for_puma
+      if defined?(::Puma) && File.basename($0) == 'puma'
+        @discovered_dispatcher = :puma
+      end
+    end
+
+    def check_for_delayed_job
+      if $0 =~ /delayed_job$/ || (File.basename($0) == 'rake' && ARGV.include?('jobs:work'))
+        @discovered_dispatcher = :delayed_job
+      end
+    end
+
+    def check_for_resque
+      has_queue              = ENV['QUEUE'] || ENV['QUEUES']
+      resque_rake            = executable == 'rake' && ARGV.include?('resque:work')
+      resque_pool_rake       = executable == 'rake' && ARGV.include?('resque:pool')
+      resque_pool_executable = executable == 'resque-pool' && defined?(::Resque::Pool)
+
+      using_resque = defined?(::Resque) &&
+        (has_queue && resque_rake) ||
+        (resque_pool_executable || resque_pool_rake)
+
+      @discovered_dispatcher = :resque if using_resque
+    end
+
+    def check_for_sidekiq
+      if defined?(::Sidekiq) && File.basename($0) == 'sidekiq'
+        @discovered_dispatcher = :sidekiq
+      end
+    end
+
+    def check_for_thin
+      if defined?(::Thin) && defined?(::Thin::Server)
+        @discovered_dispatcher = :thin
+      end
+    end
+
+    def check_for_passenger
+      if defined?(::PhusionPassenger)
+        @discovered_dispatcher = :passenger
+      end
+    end
+
+    def check_for_goliath
+      if defined?(::Goliath) && defined?(::Goliath::API)
+        @discovered_dispatcher = :goliath
+      end
+    end
+
+    public
+    # outputs a human-readable description
+    def to_s
+      s = "LocalEnvironment["
+      s << ";dispatcher=#{@discovered_dispatcher}" if @discovered_dispatcher
+      s << "]"
+    end
+
+    def executable
+      File.basename($0)
+    end
+
+  end
+end