tingyun_rpm 1.0.6

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

@@ -0,0 +1,84 @@
+# encoding: utf-8
+# This file is distributed under Ting Yun's license terms.
+
+# This module was normalize the date encode
+require 'ting_yun/support/language_support'
+
+
+module TingYun
+  module Support
+    module Serialize
+      module EncodingNormalizer
+        def self.normalize_object(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_object(x) }
+            when Hash
+              return object if object.empty?
+              hash = {}
+              object.each 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_object(v)
+              end
+              hash
+            else
+              object
+          end
+        end
+        def self.normalize_string(str)
+          @normalizer ||= choose_normalizer
+          @normalizer.normalize(str)
+        end
+
+        def self.choose_normalizer
+          if TingYun::Support::LanguageSupport.supports_string_encodings?
+            EncodingNormalizer
+          else
+            IconvNormalizer
+          end
+        end
+
+        module EncodingNormalizer
+          def self.normalize(str)
+            encoding = str.encoding
+            if (encoding == Encoding::UTF_8 || encoding == Encoding::ISO_8859_1) && str.valid_encoding?
+              return str
+            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 = str.dup
+            if encoding == Encoding::ASCII_8BIT || !str.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
+
+
+        module IconvNormalizer
+          def self.normalize(raw_string)
+            if @iconv.nil?
+              require 'iconv'
+              @iconv = Iconv.new('utf-8', 'iso-8859-1')
+            end
+            @iconv.iconv(raw_string)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+# encoding: utf-8
+# This file is distributed under Ting Yun's license terms.
+
+require 'ting_yun/support/serialize/marshaller'
+require 'ting_yun/support/serialize/json_wrapper'
+require 'ting_yun/support/version_number'
+
+
+module TingYun
+  module Support
+    module Serialize
+      # Marshal collector protocol with JSON when available
+      class JsonMarshaller < Marshaller
+        def initialize
+          TingYun::Agent.logger.debug "Using JSON marshaller (#{JSONWrapper.backend_name})"
+          unless self.class.is_supported?
+            TingYun::Agent.logger.warn "The JSON marshaller in use (#{JSONWrapper.backend_name}) is not recommended. Ensure the 'json' gem is available in your application for better performance."
+          end
+          warn_for_yajl
+        end
+
+        OK_YAJL_VERSION = TingYun::Support::VersionNumber.new("1.2.1")
+
+        def warn_for_yajl
+          if defined?(::Yajl)
+            require 'yajl/version'
+            if VersionNumber.new(::Yajl::VERSION) < OK_YAJL_VERSION
+              ::TingYun::Agent.logger.warn "Detected yajl-ruby version #{::Yajl::VERSION} which can cause segfaults with TingYun_rpm's thread profiling features. We strongly recommend you upgrade to the latest yajl-ruby version available."
+            end
+          end
+        rescue => err
+          ::TingYun::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 = TingYun::Agent.config[:normalize_json_string_encodings]
+          end
+
+          JSONWrapper.dump(prepared, :normalize => normalize_encodings)
+        end
+
+        def load(data)
+          if data.nil? || data.empty?
+            ::TingYun::Agent.logger.error "Empty JSON response from collector: '#{data.inspect}'"
+            return nil
+          end
+
+          return_value(JSONWrapper.load(data))
+        rescue => e
+          ::TingYun::Agent.logger.debug "#{e.class.name} : #{e.message} encountered loading collector response: #{data}"
+          raise
+        end
+
+        def format
+          'json'
+        end
+
+        def self.is_supported?
+          JSONWrapper.usable_for_collector_serialization?
+        end
+
+        def self.human_readable?
+          true # for some definitions of 'human'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+# encoding: utf-8
+# This file is distributed under Ting Yun's license terms.
+
+require 'ting_yun/support/serialize/encoding_normalizer'
+require 'ting_yun/support/language_support'
+require 'ting_yun/support/hash_extensions'
+
+module TingYun
+  module Support
+    module Serialize
+      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, :quirks_mode => true}
+            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 => err
+            TingYun::Agent.logger.debug "%p while loading JSON library: %s" % [err, err.message] if defined?(TingYun::Agent) && TingYun::Agent.respond_to?(:logger)
+          end
+        end
+
+        def self.load_ok_json
+          require 'ting_yun/support/serialize/ok_json'
+          @load_method = OkJson.method(:decode)
+          @dump_method = OkJson.method(:encode)
+          @backend_name = :ok_json
+        end
+
+        load_native_json or load_ok_json
+
+        def self.usable_for_collector_serialization?
+          @backend_name == :json
+        end
+
+        def self.backend_name
+          @backend_name
+        end
+
+        def self.supports_normalization?
+          TingYun::Support::LanguageSupport.supports_string_encodings?
+        end
+
+        def self.dump(object, options={})
+          object = normalize(object) if options[:normalize]
+          # ok_json doesn't handle symbol keys, so we must stringify them before encoding
+          object = TingYun::Support::HashExtensions.stringify_keys_in_object(object) if backend_name == :ok_json
+          @dump_method.call(object)
+        end
+
+        def self.load(string)
+          @load_method.call(string)
+        end
+
+        def self.normalize(o)
+          TingYun::Support::Serialize::EncodingNormalizer.normalize_object(o)
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,69 @@
+# encoding: utf-8
+# This file is distributed under Ting Yun's license terms.
+require 'ting_yun/agent'
+require 'ting_yun/support/exception'
+
+module TingYun
+  module Support
+    module Serialize
+      class Marshaller
+        def parsed_error(error)
+          error_code = error['errorCode']
+          error_message = error['errorMessage']
+          case error_code
+            when 460
+              raise TingYun::Support::Exception::LicenseException.new("#{error_code}: #{error_message}")
+            when 461
+              raise TingYun::Support::Exception::InvalidDataTokenException.new("#{error_code}: #{error_message}")
+            when 462
+              raise TingYun::Support::Exception::InvalidDataException.new("#{error_code}: #{error_message}")
+            when 470
+              raise TingYun::Support::Exception::ExpiredConfigurationException.new("#{error_code}: #{error_message}")
+          end
+        end
+
+        def prepare(data, options={})
+          encoder = options[:encoder] || default_encoder
+          if data.respond_to?(:to_collector_array)
+            data.to_collector_array(encoder)
+          elsif data.kind_of?(Array)
+            data.map { |element| prepare(element, options) }
+          elsif data.kind_of?(Hash)
+            data.each {|_k,_v| data[_k]=prepare(_v, options)}
+          else
+            data
+          end
+        end
+
+        def default_encoder
+          Encoders::Identity
+        end
+
+        def self.human_readable?
+          false
+        end
+
+        def return_value_for_testing(data)
+          return_value(data)
+        end
+
+        protected
+
+        def return_value(data)
+          if data.respond_to?(:has_key?)
+            if data.has_key?('status') && data.has_key?('result')
+              if data['status'] =="error"
+                parsed_error(data['result'])
+              elsif data['result']['enabled'] == false
+                raise TingYun::Support::Exception::AgentEnableException.new("sorry，the application is unable to use the tingyun service now ")
+              else
+                return data['result']
+              end
+            end
+          end
+          data
+        end
+      end
+    end
+  end
+end