oneapm_rpm 1.1.0

data/lib/one_apm/support/http_clients/excon_wrappers.rb

@@ -0,0 +1,63 @@
+# encoding: utf-8
+
+module OneApm
+  module Support
+    module HTTPClients
+      class ExconHTTPResponse
+        def initialize(response)
+          @response = response
+          # Since HTTP headers are case-insensitive, we normalize all of them to
+          # upper case here, and then also in our [](key) implementation.
+          @normalized_headers = {}
+          headers = response.respond_to?(:headers) ? response.headers : response[:headers]
+          (headers || {}).each do |key, val|
+            @normalized_headers[key.upcase] = val
+          end
+        end
+
+        def [](key)
+          @normalized_headers[key.upcase]
+        end
+
+        def to_hash
+          @normalized_headers.dup
+        end
+      end
+
+      class ExconHTTPRequest
+        def initialize(datum)
+          @datum = datum
+        end
+
+        def type
+          "Excon"
+        end
+
+        def host
+          if hostname = (self['host'] || self['Host'])
+            hostname.split(':').first
+          else
+            @datum[:host]
+          end
+        end
+
+        def method
+          @datum[:method].to_s.upcase
+        end
+
+        def [](key)
+          @datum[:headers][key]
+        end
+
+        def []=(key, value)
+          @datum[:headers] ||= {}
+          @datum[:headers][key] = value
+        end
+
+        def uri
+          URI.parse("#{@datum[:scheme]}://#{@datum[:host]}:#{@datum[:port]}#{@datum[:path]}")
+        end
+      end
+    end
+  end
+end

data/lib/one_apm/support/http_clients/httpclient_wrappers.rb

@@ -0,0 +1,61 @@
+# encoding: utf-8
+
+module OneApm
+  module Support
+    module HTTPClients
+      class HTTPClientResponse
+        attr_reader :response
+
+        def initialize(response)
+          @response = response
+        end
+
+        def [](key)
+          response.headers.each do |k,v|
+            if key.downcase == k.downcase
+              return v
+            end
+          end
+          nil
+        end
+
+        def to_hash
+          response.headers
+        end
+      end
+
+      class HTTPClientRequest
+        attr_reader :request, :uri
+
+        def initialize(request)
+          @request = request
+          @uri = request.header.request_uri
+        end
+
+        def type
+          "HTTPClient"
+        end
+
+        def method
+          request.header.request_method
+        end
+
+        def host
+          if hostname = (self['host'] || self['Host'])
+            hostname.split(':').first
+          else
+            uri.host.to_s
+          end
+        end
+
+        def [](key)
+          request.headers[key]
+        end
+
+        def []=(key, value)
+          request.http_header[key] = value
+        end
+      end
+    end
+  end
+end

data/lib/one_apm/support/http_clients/net_http_wrappers.rb

@@ -0,0 +1,48 @@
+# encoding: utf-8
+
+module OneApm
+  module Support
+    module HTTPClients
+      class NetHTTPRequest
+        def initialize(connection, request)
+          @connection = connection
+          @request = request
+        end
+
+        def type
+          'Net::HTTP'
+        end
+
+        def host
+          if hostname = self['host']
+            hostname.split(':').first
+          else
+            @connection.address
+          end
+        end
+
+        def method
+          @request.method
+        end
+
+        def [](key)
+          @request[key]
+        end
+
+        def []=(key, value)
+          @request[key] = value
+        end
+
+        def uri
+          case @request.path
+          when /^https?:\/\//
+            URI(@request.path)
+          else
+            scheme = @connection.use_ssl? ? 'https' : 'http'
+            URI("#{scheme}://#{@connection.address}:#{@connection.port}#{@request.path}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/one_apm/support/http_clients/typhoeus_wrappers.rb

@@ -0,0 +1,73 @@
+# encoding: utf-8
+
+module OneApm
+  module Support
+    module HTTPClients
+      class TyphoeusHTTPResponse
+        def initialize(response)
+          @response = response
+        end
+
+        def [](key)
+          unless headers.nil?
+            result = headers[key]
+
+            # Typhoeus 0.5.3 has a bug where asking the headers hash for a
+            # non-existent header will return the hash itself, not what we want.
+            result == headers ? nil : result
+          end
+        end
+
+        def to_hash
+          hash = {}
+          headers.each do |(k,v)|
+            hash[k] = v
+          end
+          hash
+        end
+
+        private
+
+        def headers
+          @response.headers
+        end
+      end
+
+      class TyphoeusHTTPRequest
+        def initialize(request)
+          @request = request
+          @uri = case request.url
+            when ::URI then request.url
+            else OneApm::Support::HTTPClients::URIUtil.parse_url(request.url)
+            end
+        end
+
+        def type
+          "Typhoeus"
+        end
+
+        def host
+          self['host'] || self['Host'] || @uri.host
+        end
+
+        def method
+          (@request.options[:method] || 'GET').to_s.upcase
+        end
+
+        def [](key)
+          return nil unless @request.options && @request.options[:headers]
+          @request.options[:headers][key]
+        end
+
+        def []=(key, value)
+          @request.options[:headers] ||= {}
+          @request.options[:headers][key] = value
+        end
+
+        def uri
+          @uri
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# 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 OneApm
+  module Support
+    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
+
+      end
+    end
+  end
+end

data/lib/one_apm/support/json_marshaller.rb

@@ -0,0 +1,68 @@
+# encoding: utf-8
+
+require 'one_apm/support/marshaller'
+
+module OneApm
+  module Support
+    class JsonMarshaller < Marshaller
+
+      OK_YAJL_VERSION = OneApm::VersionNumber.new("1.2.1")
+
+      def initialize
+        ::OneApm::Agent.logger.info "Using JSON marshaller (#{OneApm::JSONWrapper.backend_name})"
+        warn_for_yajl
+      end
+
+      def warn_for_yajl
+        if defined?(::Yajl)
+          require 'yajl/version'
+          if OneApm::VersionNumber.new(::Yajl::VERSION) < OK_YAJL_VERSION
+            ::OneApm::Agent.logger.warn "Detected yajl-ruby version #{::Yajl::VERSION} which can cause segfaults with oneapm_rpm's thread profiling features. We strongly recommend you upgrade to the latest yajl-ruby version available."
+          end
+        end
+      rescue => err
+        ::OneApm::Agent.logger.warn "Failed trying to watch for problematic yajl-ruby version.", err
+      end
+
+      def dump(ruby, opts={})
+        prepared = prepare(ruby, opts)
+
+        if opts[:skip_normalization]
+          normalize_encodings = false
+        else
+          normalize_encodings = Agent.config[:normalize_json_string_encodings]
+        end
+
+        OneApm::JSONWrapper.dump prepared, :normalize => normalize_encodings
+      end
+
+      def load(data)
+        if data.nil? || data.empty?
+          ::OneApm::Agent.logger.error "Empty JSON response from collector: '#{data.inspect}'"
+          return nil
+        end
+
+        return_value OneApm::JSONWrapper.load(data)
+      rescue => e
+        ::OneApm::Agent.logger.debug "#{e.class.name} : #{e.message} encountered loading collector response: #{data}"
+        raise
+      end
+
+      def default_encoder
+        Encoders::Base64CompressedJSON
+      end
+
+      def self.is_supported?
+        OneApm::JSONWrapper.usable_for_collector_serialization?
+      end
+
+      def format
+        'json'
+      end
+
+      def self.human_readable?
+        true # for some definitions of 'human'
+      end
+    end
+  end
+end

data/lib/one_apm/support/json_wrapper.rb

@@ -0,0 +1,130 @@
+# encoding: utf-8
+
+module OneApm
+  class JSONWrapper
+    def self.load_native_json
+      begin
+        require 'json' unless defined?(::JSON)
+
+        # yajl's replacement methods on ::JSON override both dump and generate.
+        # Because stdlib dump just calls generate, we end up calling into yajl
+        # when we don't want to. As such, we use generate directly instead of
+        # dump, although we have to fuss with defaults to make that ok.
+        generate_method = ::JSON.method(:generate)
+        if ::JSON.respond_to?(:dump_default_options)
+          options = ::JSON.dump_default_options
+        else
+          # These were the defaults from json 1.1.9 up to 1.6.1
+          options = { :allow_nan => true, :max_nesting => false }
+        end
+        @dump_method = Proc.new do |obj|
+          generate_method.call(obj, options)
+        end
+
+        @load_method    = ::JSON.method(:load)
+        @backend_name   = :json
+        return true
+      rescue StandardError, ScriptError
+        OneApm::Agent.logger.debug "%p while loading JSON library: %s" % [ err, err.message ] if
+          defined?( OneApm::Agent ) && OneApm::Agent.respond_to?( :logger )
+      end
+    end
+
+    def self.load_okjson
+      require 'one_apm/support/okjson'
+      @load_method = ::OneApm::Support::OkJson.method(:decode)
+      @dump_method = ::OneApm::Support::OkJson.method(:encode)
+      @backend_name = :okjson
+    end
+
+    load_native_json or load_okjson
+
+    def self.usable_for_collector_serialization?
+      @backend_name == :json
+    end
+
+    def self.backend_name
+      @backend_name
+    end
+
+    def self.normalize_string(s)
+      choose_normalizer unless @normalizer
+      @normalizer.normalize(s)
+    end
+
+    def self.choose_normalizer
+      if OneApm::LanguageSupport.supports_string_encodings?
+        @normalizer = EncodingNormalizer
+      else
+        @normalizer = IconvNormalizer
+      end
+    end
+
+    class EncodingNormalizer
+      def self.normalize(s)
+        encoding = s.encoding
+        if (encoding == Encoding::UTF_8 || encoding == Encoding::ISO_8859_1) && s.valid_encoding?
+          return s
+        end
+
+        # If the encoding is not valid, or it's ASCII-8BIT, we know conversion to
+        # UTF-8 is likely to fail, so treat it as ISO-8859-1 (byte-preserving).
+        normalized = s.dup
+        if encoding == Encoding::ASCII_8BIT || !s.valid_encoding?
+          normalized.force_encoding(Encoding::ISO_8859_1)
+        else
+          # Encoding is valid and non-binary, so it might be cleanly convertible
+          # to UTF-8. Give it a try and fall back to ISO-8859-1 if it fails.
+          begin
+            normalized.encode!(Encoding::UTF_8)
+          rescue
+            normalized.force_encoding(Encoding::ISO_8859_1)
+          end
+        end
+        normalized
+      end
+    end
+
+    class IconvNormalizer
+      def self.normalize(s)
+        if @iconv.nil?
+          require 'iconv'
+          @iconv = Iconv.new('utf-8', 'iso-8859-1')
+        end
+        @iconv.iconv(s)
+      end
+    end
+
+    def self.normalize(object)
+      case object
+      when String
+        normalize_string(object)
+      when Symbol
+        normalize_string(object.to_s)
+      when Array
+        return object if object.empty?
+        object.map { |x| normalize(x) }
+      when Hash
+        return object if object.empty?
+        hash = {}
+        object.each_pair do |k, v|
+          k = normalize_string(k)      if k.is_a?(String)
+          k = normalize_string(k.to_s) if k.is_a?(Symbol)
+          hash[k] = normalize(v)
+        end
+        hash
+      else
+        object
+      end
+    end
+
+    def self.dump(object, options={})
+      object = normalize(object) if options[:normalize]
+      @dump_method.call(object)
+    end
+
+    def self.load(string)
+      @load_method.call(string)
+    end
+  end
+end