tingyun_rpm 1.0.6

data/lib/ting_yun/configuration/environment_source.rb

@@ -0,0 +1,116 @@
+# encoding: utf-8
+# This file is distributed under Ting Yun's license terms.
+
+require 'ting_yun/configuration/dotted_hash'
+
+
+module TingYun
+  module Configuration
+    class EnvironmentSource < DottedHash
+      SUPPORTED_PREFIXES = /^ting_yun_|^tingyun_/i
+      SPECIAL_CASE_KEYS = [
+          'TING_YUN_ENV',
+          'TING_YUN_LOG' # read by set_log_file
+      ]
+
+      attr_accessor :alias_map, :type_map
+
+      def initialize
+        set_config_file
+        set_log_file
+
+        @alias_map = {}
+        @type_map = {}
+
+        DEFAULTS.each do |config_setting, value|
+          self.type_map[config_setting] = value[:type]
+          set_aliases(config_setting, value)
+        end
+
+        set_values_from_ting_yun_environment_variables
+      end
+
+      def set_aliases(config_setting, value)
+        set_dotted_alias(config_setting)
+
+        return unless value[:aliases]
+        value[:aliases].each do |alise|
+          self.alias_map[alise] = config_setting
+        end
+      end
+
+      def set_dotted_alias(original_config_setting)
+        config_setting = original_config_setting.to_s
+
+
+        if config_setting.include? '.'
+          config_alias = config_setting.gsub(/\./, '_').to_sym
+          self.alias_map[config_alias] = original_config_setting
+        end
+      end
+
+      def set_config_file
+        self[:config_path] = ENV['NRCONFIG'] if ENV['NRCONFIG']
+      end
+
+
+      def set_log_file
+        if ENV['TING_YUN_LOG']
+          if ENV['TING_YUN_LOG'].upcase == 'STDOUT'
+            self[:log_file_path] = self[:log_file_name] = 'STDOUT'
+          else
+            self[:log_file_path] = File.dirname(ENV['TING_YUN_LOG'])
+            self[:log_file_name] = File.basename(ENV['TING_YUN_LOG'])
+          end
+        end
+      end
+
+      def set_values_from_ting_yun_environment_variables
+        env_var_keys = collect_ting_yun_environment_variable_keys
+        env_var_keys.each do |key|
+          next if SPECIAL_CASE_KEYS.include?(key.upcase)
+          set_value_from_environment_variable(key)
+        end
+      end
+
+      def set_value_from_environment_variable(key)
+        config_key = convert_environment_key_to_config_key(key)
+        set_key_by_type(config_key, key)
+      end
+
+      def set_key_by_type(config_key, environment_key)
+        value = ENV[environment_key]
+        type = self.type_map[config_key]
+
+        if type == String
+          self[config_key] = value
+        elsif type == Fixnum
+          self[config_key] = value.to_i
+        elsif type == Float
+          self[config_key] = value.to_f
+        elsif type == Symbol
+          self[config_key] = value.to_sym
+        elsif type == TingYun::Configuration::Boolean
+          if value =~ /false|off|no/i
+            self[config_key] = false
+          elsif value != nil
+            self[config_key] = true
+          end
+        else
+          # TingYun::Agent.logger.info("#{environment_key} does not have a corresponding configuration setting (#{config_key} does not exist).")
+          self[config_key] = value
+        end
+
+      end
+
+      def convert_environment_key_to_config_key(key)
+        stripped_key = key.gsub(SUPPORTED_PREFIXES, '').downcase.to_sym
+        self.alias_map[stripped_key] || stripped_key
+      end
+
+      def collect_ting_yun_environment_variable_keys
+        ENV.keys.select { |key| key.match(SUPPORTED_PREFIXES) }
+      end
+    end
+  end
+end

data/lib/ting_yun/configuration/manager.rb

@@ -0,0 +1,232 @@
+# encoding: utf-8
+# This file is distributed under Ting Yun's license terms.
+require 'ting_yun/configuration/default_source'
+require 'ting_yun/configuration/environment_source'
+require 'ting_yun/configuration/yaml_source'
+require 'ting_yun/configuration/server_source'
+require 'ting_yun/configuration/manual_source'
+
+
+module TingYun
+  module Configuration
+    class Manager
+
+      def initialize
+        reset_to_defaults
+      end
+
+      def [](key)
+        @cache[key]
+      end
+
+      def has_key?(key)
+        @cache.has_key?(key)
+      end
+
+      def keys
+        @cache.keys
+      end
+
+      def app_names
+        if TingYun::Agent.config[:'nbs.auto_app_naming']
+          begin
+          [::TingYun::Frameworks.framework.root.split('/').last]
+          rescue Exception => e
+            get_name
+          end
+        else
+          get_name
+        end
+
+      end
+
+      def get_name
+        case TingYun::Agent.config[:app_name]
+          when Array then
+            TingYun::Agent.config[:app_name]
+          when String then
+            TingYun::Agent.config[:app_name].split(';')
+          else
+            []
+        end
+      end
+
+      def reset_to_defaults
+        @default_source = DefaultSource.new
+        @environment_source = EnvironmentSource.new
+        @yaml_source = nil
+        @server_source  = nil
+        @manual_source = nil
+        # @callbacks = Hash.new {|hash,key| hash[key] =[]}#存放需要merge本地和服务端配置的info'
+
+        @configs_for_testing = []
+
+        reset_cache
+      end
+
+      def reset_cache
+        @cache = Hash.new { |hash, key| hash[key] = self.fetch(key) }
+      end
+
+      def fetch(key)
+        config_stack.each do |config|
+          next unless config
+          accessor = key.to_sym
+
+          if config.has_key?(accessor)
+            return evaluated = evaluate_procs(config[accessor]) #if it's proc
+          end
+        end
+        nil
+      end
+
+      def evaluate_procs(value)
+        if value.respond_to?(:call)
+          instance_eval(&value)
+        else
+          value
+        end
+      end
+
+      def add_config_for_testing(source, level=0)
+        raise 'Invalid config type for testing' unless [Hash, DottedHash].include?(source.class)
+        @configs_for_testing << [source.freeze, level]
+        reset_cache
+        log_config(:add, source)
+      end
+
+      def remove_config_type(sym)
+        source = case sym
+                   when :environment then   @environment_source
+                   when :server      then   @server_source
+                   when :manual      then   @manual_source
+                   when :yaml        then   @yaml_source
+                   when :default     then   @default_source
+                 end
+        remove_config(source)
+      end
+
+
+      def remove_config(source)
+        case source
+          when YamlSource         then  @yaml_source          = nil
+          when DefaultSource      then  @default_source       = nil
+          when EnvironmentSource  then  @environment_source   = nil
+          when ManualSource       then  @manual_source        = nil
+          when ServerSource       then  @server_source        = nil
+          else
+            @configs_for_testing.delete_if { |src, lvl| src == source }
+        end
+
+        reset_cache
+
+        #invoke_callbacks(:remove,source)
+
+        log_config(:remove, source)
+
+      end
+
+      def replace_or_add_config(source)
+        source.freeze
+
+        was_finished = finished_configuring?
+
+        case source
+          when YamlSource        then   @yaml_source          = source
+          when DefaultSource     then   @default_source       = source
+          when EnvironmentSource then   @environment_source   = source
+          when ServerSource      then   @server_source        = source
+          when ManualSource      then   @manual_source        = source
+          else
+            TingYun::Agent.logger.warn("Invalid config format; config will be ignored: #{source}")
+        end
+        reset_cache
+
+        log_config(:add, source)
+
+        notify_finished_configuring if !was_finished && finished_configuring?
+      end
+
+      def notify_finished_configuring
+        TingYun::Agent.instance.events.notify(:finished_configuring)
+      end
+
+      def finished_configuring?
+        !@server_source.nil?
+      end
+
+
+      def source(key)
+        config_stack.each do |config|
+          if config.respond_to?(key.to_sym) || config.has_key?(key.to_sym)
+            return config
+          end
+        end
+      end
+
+      def log_config(direction, source)
+        # Just generating this log message (specifically calling
+        # flattened.inspect) is expensive enough that we don't want to do it
+        # unless we're actually going to be logging the message based on our
+        # current log level.
+        ::TingYun::Agent.logger.debug do
+          "Updating config (#{direction}) from #{source.class}. Results: #{flattened.inspect}"
+        end
+      end
+
+      def flattened
+        config_stack.reverse.inject({}) do |flat, layer|
+          thawed_layer = layer.to_hash.dup
+          thawed_layer.each do |k, v|
+            begin
+              thawed_layer[k] = instance_eval(&v) if v.respond_to?(:call)
+            rescue => e
+              ::TingYun::Agent.logger.debug("#{e.class.name} : #{e.message} - when accessing config key #{k}")
+              thawed_layer[k] = nil
+            end
+            thawed_layer.delete(:config)
+          end
+          flat.merge(thawed_layer.to_hash)
+        end
+      end
+
+      def config_classes_for_testing
+        config_stack.map(&:class)
+      end
+
+
+
+
+      def to_collector_hash
+        DottedHash.new(flattened).to_hash.delete_if do |k, v|
+          default = DEFAULTS[k]
+          if default
+            default[:exclude_from_reported_settings]
+          else
+            # In our tests, we add totally bogus configs, because testing.
+            # In those cases, there will be no default. So we'll just let
+            # them through.
+            false
+          end
+        end
+      end
+
+      private
+
+      def config_stack
+        stack = [@environment_source, @server_source, @manual_source, @yaml_source, @default_source]
+
+        stack.compact!
+        @configs_for_testing.each do |config, at_start|
+          if at_start
+            stack.insert(0, config)
+          else
+            stack.push(config)
+          end
+        end
+
+        stack
+      end
+    end
+  end
+end

data/lib/ting_yun/configuration/manual_source.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+# This file is distributed under Ting Yun's license terms.
+
+require 'ting_yun/configuration/dotted_hash'
+
+module TingYun
+  module Configuration
+    class ManualSource < DottedHash
+      def initialize(hash)
+        super(hash, true)
+      end
+    end
+  end
+end

data/lib/ting_yun/configuration/server_source.rb

@@ -0,0 +1,88 @@
+# encoding: utf-8
+# This file is distributed under Ting Yun's license terms.
+
+require 'ting_yun/configuration/dotted_hash'
+
+module TingYun
+  module Configuration
+    class ServerSource < DottedHash
+      # These keys appear *outside* of the agent_config hash in the connect
+      # response, but should still be merged in as config settings to the
+      # main agent configuration.
+      TOP_LEVEL_KEYS = [
+          "applicationId",
+          "tingyunIdSecret",
+          "enabled",
+          "appSessionKey",
+          "dataSentInterval",
+          "apdex_t",
+          "config"
+      ]
+
+      def self.add_top_level_keys_for_testing(add_array)
+        TOP_LEVEL_KEYS.concat add_array
+      end
+
+      def self.remove_top_level_keys_for_testing(remove_arry)
+        remove_arry.each{|i| TOP_LEVEL_KEYS.delete(i)}
+      end
+
+      def initialize(connect_reply)
+        merged_settings = {}
+
+        merge_top_level_keys(merged_settings, connect_reply)
+        merge_agent_config_hash(merged_settings, connect_reply)
+        filter_keys(merged_settings)
+        # apply_feature_gates(merged_settings, connect_reply, existing_config)
+
+        # The value under this key is a hash mapping transaction name strings
+        # to apdex_t values. We don't want the nested hash to be flattened
+        # as part of the call to super below, so it skips going through
+        # merged_settings.
+        # self[:web_transactions_apdex] = connect_reply['web_transactions_apdex']
+
+        # This causes keys in merged_settings to be symbolized and flattened
+        super(merged_settings)
+      end
+
+      def merge_top_level_keys(merged_settings, connect_reply)
+        TOP_LEVEL_KEYS.each do |key_name|
+          if connect_reply[key_name]
+            merged_settings[key_name] = connect_reply[key_name]
+          end
+        end
+      end
+
+      def merge_agent_config_hash(merged_settings, connect_reply)
+        if connect_reply['config']
+          merged_settings.merge!(connect_reply['config'])
+        end
+      end
+
+      def fix_transaction_threshold(merged_settings)
+        # when value is "apdex_f" remove the config and defer to default
+        if merged_settings['transaction_tracer.transaction_threshold'] =~ /apdex_f/i
+          merged_settings.delete('transaction_tracer.transaction_threshold')
+        end
+      end
+
+      def filter_keys(merged_settings)
+        merged_settings.delete_if do |key, _|
+          setting_spec = DEFAULTS[key.to_sym]
+          if setting_spec
+            if setting_spec[:allowed_from_server]
+              false # it's allowed, so don't delete it
+            else
+              TingYun::Agent.logger.warn("Ignoring server-sent config for '#{key}' - this setting cannot be set from the server")
+              true # delete it
+            end
+          else
+            TingYun::Agent.logger.debug("Ignoring unrecognized config key from server: '#{key}'")
+            true
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/ting_yun/configuration/yaml_source.rb

@@ -0,0 +1,136 @@
+# encoding: utf-8
+require 'ting_yun/configuration/dotted_hash'
+require 'ting_yun/support/language_support'
+require 'erb'
+
+module TingYun
+  module Configuration
+    class YamlSource < DottedHash
+      attr_accessor :file_path, :failures
+
+      def initialize(path, env)
+        config = {}
+        @failures = []
+
+        begin
+          @file_path = vaildate_config_file_path(path)
+          return unless @file_path
+
+          ::TingYun::Agent.logger.info("Reading configuration from #{path} (#{Dir.pwd})")
+
+          raw_file = File.read(@file_path)
+          erb_file = process_erb(raw_file)
+          config = process_yaml(erb_file, env, config, @file_path)
+        rescue ScriptError, StandardError => e
+          log_failure("Failed to read or parse configuration file at #{path}", e)
+        end
+        booleanify_values(config, 'nbs.agent_enabled', 'enabled')
+        super(config, true)
+      end
+
+      def failed?
+        !@failures.empty?
+      end
+
+      protected
+
+      def vaildate_config_file_path(path)
+        expanded_path = File.expand_path(path)
+
+        if path.empty? || !File.exist?(expanded_path)
+          warn_missing_config_file(expanded_path)
+          return
+        end
+        expanded_path
+      end
+
+      def warn_missing_config_file(path)
+        based_on = 'unknown'
+        source = ::TingYun::Agent.config.source(:config_path)
+        candidate_paths = [path]
+
+        case source
+          when DefaultSource
+            based_on = "default"
+            candidate_paths = TingYun::Agent.config[:config_search_paths].map do |p|
+              File.expand_path(p)
+            end
+          when EnvironmentSource
+            based_on = "environment_source"
+          when ManualSource
+            based_on = 'API call'
+        end
+
+        TingYun::Agent.logger.warn(
+            "No configuration file found. Working directory = #{Dir.pwd}",
+            "Looked in these locations (based on #{based_on}): #{candidate_paths.join(", ")}"
+        )
+      end
+
+      def process_erb(file)
+        begin
+          # Exclude lines that are commented out so failing Ruby code in an
+          # ERB template commented at the YML level is fine. Leave the line,
+          # though, so ERB line numbers remain correct.
+          file.gsub!(/^\s*#.*$/, '#')
+
+          # Next two are for populating the tingyun.yml via erb binding, necessary
+          # when using the default tingyun.yml file
+          generated_for_user = ''
+          license_key = ''
+
+          ERB.new(file).result(binding)
+        rescue ScriptError, StandardError => e
+          log_failure("Failed ERB processing configuration file. This is typically caused by a Ruby error in <% %> templating blocks in your tingyun.yml file.", e)
+          nil
+        ensure
+          # Avoid warnings by using these again
+          generated_for_user = nil
+          license_key = nil
+        end
+      end
+
+      def process_yaml(file, env, config, path)
+        if file
+          confighash = with_yaml_engine { YAML.load(file) }
+          unless confighash.key?(env)
+            log_failure("Config file at #{path} doesn't include a '#{env}' section!")
+          end
+
+          config = confighash[env] || {}
+        end
+        config
+      end
+
+      def with_yaml_engine
+        return yield unless TingYun::Support::LanguageSupport.needs_syck?
+
+        yamler = ::YAML::ENGINE.yamler
+        ::YAML::ENGINE.yamler = 'syck'
+        result = yield
+        ::YAML::ENGINE.yamler = yamler
+        result
+      end
+
+      def booleanify_values(config, *keys)
+        # auto means defer ro default
+        keys.each do |option|
+          if config[option] == 'auto'
+            config.delete(option)
+          elsif !config[option].nil? && !is_boolean?(config[option])
+            config[option] = !!(config[option] =~ /yes|on|true/i)
+          end
+        end
+      end
+
+      def is_boolean?(value)
+        value == !!value
+      end
+
+      def log_failure(*messages)
+        ::TingYun::Agent.logger.error(*messages)
+        @failures << messages
+      end
+    end
+  end
+end

data/lib/ting_yun/configuration.rb

@@ -0,0 +1,9 @@
+# encoding: utf-8
+# This file is distributed under Ting Yun's license terms.
+
+
+module TingYun
+  module Configuration
+
+  end
+end