tingyun_rpm 1.0.6

data/lib/ting_yun/support/helper.rb

@@ -0,0 +1,54 @@
+# encoding: utf-8
+
+
+require 'ting_yun/support/language_support'
+
+module TingYun
+  # A singleton for shared generic helper methods
+  module Helper
+    extend self
+
+    # confirm a string is correctly encoded (in >= 1.9)
+    # If not force the encoding to ASCII-8BIT (binary)
+    if TingYun::Support::LanguageSupport.supports_string_encodings?
+      def correctly_encoded(string)
+        return string unless string.is_a? String
+        # The .dup here is intentional, since force_encoding mutates the target,
+        # and we don't know who is going to use this string downstream of us.
+        string.valid_encoding? ? string : string.dup.force_encoding("ASCII-8BIT")
+      end
+    else
+      #noop
+      def correctly_encoded(string)
+        string
+      end
+    end
+
+    def instance_method_visibility(klass, method_name)
+      if klass.private_instance_methods.map{|s|s.to_sym}.include? method_name.to_sym
+        :private
+      elsif klass.protected_instance_methods.map{|s|s.to_sym}.include? method_name.to_sym
+        :protected
+      else
+        :public
+      end
+    end
+
+    def instance_methods_include?(klass, method_name)
+      method_name_sym = method_name.to_sym
+      (
+      klass.instance_methods.map{ |s| s.to_sym }.include?(method_name_sym)          ||
+          klass.protected_instance_methods.map{ |s|s.to_sym }.include?(method_name_sym) ||
+          klass.private_instance_methods.map{ |s|s.to_sym }.include?(method_name_sym)
+      )
+    end
+
+    def time_to_millis(time)
+      (time.to_f * 1000).round
+    end
+
+    def milliseconds_to_seconds(milliseconds)
+      milliseconds / 1000.0
+    end
+  end
+end

data/lib/ting_yun/support/hostname.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+module TingYun
+  module Support
+    module Hostname
+
+      def self.get
+        Socket.gethostname
+      end
+
+    end
+  end
+end

data/lib/ting_yun/support/http_clients/uri_util.rb

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+
+# This module includes utilities for manipulating URIs, particularly from the
+# context of Net::HTTP requests. We don't always have direct access to the full
+# URI from our instrumentation points in Net::HTTP, and we want to filter out
+# some URI parts before saving URIs from instrumented calls - logic for that
+# lives here.
+
+module TingYun
+  module Agent
+    module HTTPClients
+      module URIUtil
+
+        def self.filter_uri(original)
+          filtered = original.dup
+          filtered.user = nil
+          filtered.password = nil
+          filtered.query = nil
+          filtered.fragment = nil
+          filtered.to_s
+        end
+
+        # There are valid URI strings that some HTTP client libraries will
+        # accept that the stdlib URI module doesn't handle. If we find that
+        # Addressable is around, use that to normalize out our URL's.
+        def self.parse_url(url)
+          if defined?(::Addressable::URI)
+            address = ::Addressable::URI.parse(url)
+            address.normalize!
+            URI.parse(address.to_s)
+          else
+            URI.parse(url)
+          end
+        end
+
+        QUESTION_MARK = "?".freeze
+
+        def self.strip_query_string(fragment)
+          if(fragment.include?(QUESTION_MARK))
+            fragment.split(QUESTION_MARK).first
+          else
+            fragment
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ting_yun/support/language_support.rb

@@ -0,0 +1,155 @@
+# encoding: utf-8
+# This file is distributed under Ting Yun's license terms.
+
+module TingYun
+  module Support
+    module LanguageSupport
+      extend self
+
+      # need to use syck rather than psych when possible
+      def needs_syck?
+        !LanguageSupport.using_engine?('jruby') &&
+            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?
+        LanguageSupport.using_version?('1.8.7') &&
+            RUBY_PATCHLEVEL < 348 &&
+            !LanguageSupport.using_engine?('jruby') &&
+            !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? && !::TingYun::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 constantize(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 unless expected_name == result.to_s
+            end
+
+            result
+          rescue NameError
+            nil
+          end
+        end
+      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 bundled_gem?(gem_name)
+        defined?(Bundler) && Bundler.rubygems.all_specs.map(&:name).include?(gem_name)
+      rescue => e
+        ::TingYun::Agent.logger.info("Could not determine if third party #{gem_name} gem is installed", e)
+        false
+      end
+    end
+  end
+end

data/lib/ting_yun/support/library_detection.rb

@@ -0,0 +1,129 @@
+# encoding: utf-8
+
+
+#
+#
+#@items=[{dependent => dependencies}...]
+#every dependent has some dependencies
+#
+module TingYun
+  module Support
+    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)
+            TingYun::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 :dependencies
+        attr_reader :executed
+        attr_accessor :name
+
+        def executed!
+          @executed = true
+        end
+
+        def dependencies_satisfied?
+          !executed and check_dependencies
+        end
+
+        def initialize
+          @dependencies = []
+          @executes = []
+          @name = nil
+        end
+
+        def execute
+          @executes.each do |e|
+            begin
+              e.call
+            rescue => err
+              TingYun::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 |depend|
+            begin
+              depend.call
+            rescue => err
+              TingYun::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 TingYun::Agent.config[key]
+            TingYun::Agent.logger.debug("Not installing #{self.name} instrumentation because of configuration #{key}")
+          else
+            true
+          end
+        end
+
+        def named(new_name)
+          self.name = new_name
+        end
+
+        def executes
+          @executes << Proc.new
+        end
+      end
+    end
+  end
+end

data/lib/ting_yun/support/local_environment.rb

@@ -0,0 +1,185 @@
+# encoding: utf-8
+# This file is distributed under Ting Yun's license terms.
+
+module TingYun
+  module Support
+    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.
+        TingYun::Support::LocalEnvironment.constants.each do | const |
+          mod = TingYun::Support::LocalEnvironment.const_get const
+          self.extend mod if mod.instance_of? Module
+        end
+        @discovered_dispatcher = nil
+        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 TingYun::Support::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
+        litespeed
+        webrick
+        fastcgi
+        rainbows
+        unicorn
+      ]
+        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)) && TingYun::Support::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)) && TingYun::Support::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)
+          # If ObjectSpace is available, use it to search for a Thin::Server
+          # instance. Otherwise, just the presence of the constant is sufficient.
+          if TingYun::Support::LanguageSupport.object_space_usable?
+            ObjectSpace.each_object(Thin::Server) do |thin_dispatcher|
+              @discovered_dispatcher = :thin
+            end
+          else
+            @discovered_dispatcher = :thin
+          end
+        end
+      end
+
+      def check_for_litespeed
+        if caller.pop =~ /fcgi-bin\/RailsRunner\.rb/
+          @discovered_dispatcher = :litespeed
+        end
+      end
+
+      def check_for_passenger
+        if defined?(::PhusionPassenger)
+          @discovered_dispatcher = :passenger
+        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
+end

data/lib/ting_yun/support/path.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+module TingYun
+  module Support
+    module Path
+      # The root directory for the plugin or gem
+      def self.ting_yun_root
+        File.expand_path(File.join("..", "..", "..",".."), __FILE__)
+      end
+
+    end
+  end
+end

data/lib/ting_yun/support/serialize/encodes.rb

@@ -0,0 +1,61 @@
+ # encoding: utf-8
+# This file is distributed under Ting Yun's license terms.
+
+require 'base64'
+require 'zlib'
+require 'ting_yun/support/serialize/json_wrapper'
+
+module TingYun
+  module Support
+    module Serialize
+      module Encoders
+        module Identity
+          def self.encode(data, opts=nil)
+            data
+          end
+        end
+
+        module Compressed
+          def self.encode(data, opts=nil)
+            Zlib::Deflate.deflate(data, Zlib::DEFAULT_COMPRESSION)
+          end
+        end
+
+        module Base64CompressedJSON
+          def self.encode(data, opts={})
+            normalize_encodings = if opts[:skip_normalization]
+                                    false
+                                  else
+                                    TingYun::Agent.config[:normalize_json_string_encodings]
+                                  end
+            json = JSONWrapper.dump(data, :normalize => normalize_encodings)
+            Base64.encode64(Compressed.encode(json))
+          end
+        end
+        module CompressedJSON
+          def self.encode(data, opts={})
+            normalize_encodings = if opts[:skip_normalization]
+                                    false
+                                  else
+                                    TingYun::Agent.config[:normalize_json_string_encodings]
+                                  end
+            json = JSONWrapper.dump(data, :normalize => normalize_encodings)
+            Compressed.encode(json)
+          end
+        end
+
+        module Json
+          def self.encode(data, opts={})
+            normalize_encodings = if opts[:skip_normalization]
+                                    false
+                                  else
+                                    TingYun::Agent.config[:normalize_json_string_encodings]
+                                  end
+            json = JSONWrapper.dump(data, :normalize => normalize_encodings)
+            return json
+          end
+        end
+      end
+    end
+  end
+end