ghazel-newrelic_rpm 3.4.0.2 → 3.5.4

data/lib/new_relic/agent/configuration/defaults.rb

@@ -0,0 +1,89 @@
+module NewRelic
+  module Agent
+    module Configuration
+      DEFAULTS = {
+        :config_path => File.join('config', 'newrelic.yml'),
+
+        :app_name   => Proc.new { NewRelic::Control.instance.env },
+        :dispatcher => Proc.new { NewRelic::Control.instance.local_env.dispatcher },
+
+        :enabled         => true,
+        :monitor_mode    => Proc.new { self[:enabled] },
+        :agent_enabled   => Proc.new do
+          self[:enabled] &&
+          (self[:developer_mode] || self[:monitor_mode] || self[:monitor_daemons]) &&
+          !!NewRelic::Control.instance.local_env.dispatcher
+        end,
+        :developer_mode  => Proc.new { self[:developer] },
+        :developer       => false,
+        :apdex_t         => 0.5,
+        :monitor_daemons => false,
+        :multi_homed     => false,
+        :high_security   => false,
+
+        :host                   => 'collector.newrelic.com',
+        :api_host               => 'rpm.newrelic.com',
+        :port                   => Proc.new { self[:ssl] ? 443 : 80 },
+        :api_port               => Proc.new { self[:port] },
+        :ssl                    => false,
+        :verify_certificate     => false,
+        :sync_startup           => false,
+        :send_data_on_exit      => true,
+        :post_size_limit        => 2 * 1024 * 1024, # 2 megs
+        :timeout                => 2 * 60,          # 2 minutes
+        :force_send             => false,
+        :send_environment_info  => true,
+        :start_channel_listener => false,
+        :data_report_period     => 60,
+        :keep_retrying          => true,
+
+        :log_file_name => 'newrelic_agent.log',
+        :log_file_path => 'log/',
+        :log_level     => 'info',
+
+        :disable_samplers                     => false,
+        :disable_resque                       => false,
+        :disable_dj                           => false,
+        :disable_view_instrumentation         => false,
+        :disable_backtrace_cleanup            => false,
+        :skip_ar_instrumentation              => false,
+        :disable_activerecord_instrumentation => Proc.new { self[:skip_ar_instrumentation] },
+        :disable_memcache_instrumentation     => false,
+        :disable_mobile_headers               => true,
+
+        :capture_memcache_keys => false,
+        :textmate              => false,
+
+        :'transaction_tracer.enabled'               => true,
+        :'transaction_tracer.transaction_threshold' => Proc.new { self[:apdex_t] * 4 },
+        :'transaction_tracer.stack_trace_threshold' => 0.5,
+        :'transaction_tracer.explain_threshold'     => 0.5,
+        :'transaction_tracer.explain_enabled'       => true,
+        :'transaction_tracer.record_sql'            => 'obfuscated',
+        :'transaction_tracer.limit_segments'        => 4000,
+        :'transaction_tracer.random_sample'         => false,
+        :sample_rate                                => 10,
+
+        :'slow_sql.enabled'               => Proc.new { self[:'transaction_tracer.enabled'] },
+        :'slow_sql.stack_trace_threshold' => Proc.new { self[:'transaction_tracer.stack_trace_threshold'] },
+        :'slow_sql.explain_threshold'     => Proc.new { self[:'transaction_tracer.explain_threshold'] },
+        :'slow_sql.explain_enabled'       => Proc.new { self[:'transaction_tracer.explain_enabled'] },
+        :'slow_sql.record_sql'            => Proc.new { self[:'transaction_tracer.record_sql'] },
+
+        :'error_collector.enabled'        => true,
+        :'error_collector.capture_source' => true,
+        :'error_collector.ignore_errors'  => 'ActionController::RoutingError',
+
+        :'rum.enabled'            => true,
+        :'rum.jsonp'              => true,
+        :'rum.load_episodes_file' => true,
+        :'browser_monitoring.auto_instrument' => Proc.new { self[:'rum.enabled'] },
+
+        :'thread_profiler.is_supported' => Proc.new { NewRelic::Agent::ThreadProfiler.is_supported? },
+        :'thread_profiler.enabled'      => Proc.new { self[:'thread_profiler.is_supported'] },
+
+        :marshaller => Proc.new { NewRelic::Agent::NewRelicService::JsonMarshaller.is_supported? ? :json : :pruby }
+      }.freeze
+    end
+  end
+end

data/lib/new_relic/agent/configuration/environment_source.rb

@@ -0,0 +1,56 @@
+module NewRelic
+  module Agent
+    module Configuration
+      class EnvironmentSource < DottedHash
+        def initialize
+          string_map = {
+            'NRCONFIG'              => :config_path,
+            'NEW_RELIC_LICENSE_KEY' => :license_key,
+            'NEWRELIC_LICENSE_KEY'  => :license_key,
+            'NEW_RELIC_APP_NAME'    => :app_name,
+            'NEWRELIC_APP_NAME'     => :app_name,
+            'NEW_RELIC_DISPATCHER'  => :dispatcher,
+            'NEWRELIC_DISPATCHER'   => :dispatcher,
+            'NEW_RELIC_FRAMEWORK'   => :framework,
+            'NEWRELIC_FRAMEWORK'    => :framework
+          }.each do |key, val|
+            self[val] = ENV[key] if ENV[key]
+          end
+
+          boolean_map = {
+            'NEWRELIC_ENABLE' => :agent_enabled
+          }.each do |key, val|
+            if ENV[key].to_s =~ /false|off|no/i
+              self[val] = false
+            elsif ENV[key] != nil
+              self[val] = true
+            end
+          end
+
+          if ENV['NEW_RELIC_LOG']
+            if ENV['NEW_RELIC_LOG'].upcase == 'STDOUT'
+              self[:log_file_path] = self[:log_file_name] = 'STDOUT'
+            else
+              self[:log_file_path] = File.dirname(ENV['NEW_RELIC_LOG'])
+              self[:log_file_name] = File.basename(ENV['NEW_RELIC_LOG'])
+            end
+          end
+
+          initialize_thread_profiler_settings
+        end
+
+
+        def initialize_thread_profiler_settings
+          thread_profiler_supported = NewRelic::Agent::ThreadProfiler.is_supported?
+          self[:'thread_profiler.is_supported'] = thread_profiler_supported
+
+          # If not supporting thread profiling, ignore all other enabled's.
+          # Otherwise, don't set so defaulting is heeded.
+          if !thread_profiler_supported
+            self[:'thread_profiler.enabled'] = false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/configuration/manager.rb

@@ -0,0 +1,116 @@
+require 'forwardable'
+require 'new_relic/agent/configuration/defaults'
+require 'new_relic/agent/configuration/yaml_source'
+require 'new_relic/agent/configuration/server_source'
+require 'new_relic/agent/configuration/environment_source'
+
+module NewRelic
+  module Agent
+    module Configuration
+      class Manager
+        extend Forwardable
+        def_delegators :@cache, :[], :has_key?
+        attr_reader :config_stack # mainly for testing
+
+        def initialize
+          @config_stack = [ EnvironmentSource.new, DEFAULTS ]
+          @cache = Hash.new {|hash,key| hash[key] = self.fetch(key) }
+          @callbacks = Hash.new {|hash,key| hash[key] = [] }
+        end
+
+        def apply_config(source, level=0)
+          invoke_callbacks(:add, source)
+          @config_stack.insert(level, source.freeze)
+          reset_cache
+        end
+
+        def remove_config(source=nil)
+          if block_given?
+            @config_stack.delete_if {|c| yield c }
+          else
+            @config_stack.delete(source)
+          end
+          reset_cache
+          invoke_callbacks(:remove, source)
+        end
+
+        def replace_or_add_config(source, level=0)
+          idx = @config_stack.map{|s| s.class}.index(source.class)
+          @config_stack.delete_at(idx) if idx
+          apply_config(source, idx || level)
+        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 fetch(key)
+          @config_stack.each do |config|
+            next unless config
+            accessor = key.to_sym
+            if config.has_key?(accessor)
+              if config[accessor].respond_to?(:call)
+                return instance_eval(&config[accessor])
+              else
+                return config[accessor]
+              end
+            end
+          end
+          nil
+        end
+
+        def register_callback(key, &proc)
+          @callbacks[key] << proc
+          proc.call(@cache[key])
+        end
+
+        def invoke_callbacks(direction, source)
+          return unless source
+          source.keys.each do |key|
+            if @cache[key] != source[key]
+              @callbacks[key].each do |proc|
+                if direction == :add
+                  proc.call(source[key])
+                else
+                  proc.call(@cache[key])
+                end
+              end
+            end
+          end
+        end
+
+        def flattened_config
+          @config_stack.reverse.inject({}) do |flat,layer|
+            thawed_layer = layer.dup
+            thawed_layer.each do |k,v|
+              begin
+                thawed_layer[k] = instance_eval(&v) if v.respond_to?(:call)
+              rescue => e
+                NewRelic::Control.instance.log.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)
+          end
+        end
+
+        def app_names
+          case self[:app_name]
+          when Array then self[:app_name]
+          when String then self[:app_name].split(';')
+          else []
+          end
+        end
+
+        def reset_cache
+          @cache = Hash.new {|hash,key| hash[key] = self.fetch(key) }
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/configuration/server_source.rb

@@ -0,0 +1,27 @@
+module NewRelic
+  module Agent
+    module Configuration
+      class ServerSource < DottedHash
+        def initialize(hash)
+          if hash['agent_config']
+            if hash['agent_config']['transaction_tracer.transaction_threshold'] =~ /apdex_f/i
+              # when value is "apdex_f" remove the config and defer to default
+              hash['agent_config'].delete('transaction_tracer.transaction_threshold')
+            end
+            super(hash.delete('agent_config'))
+          end
+
+          string_map = [
+             ['collect_traces', 'transaction_tracer.enabled'],
+             ['collect_traces', 'slow_sql.enabled'],
+             ['collect_errors', 'error_collector.enabled']
+          ].each do |pair|
+            hash[pair[1]] = hash[pair[0]] if hash[pair[0]] != nil
+          end
+
+          super
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/configuration/yaml_source.rb

@@ -0,0 +1,61 @@
+require 'new_relic/agent/configuration'
+
+module NewRelic
+  module Agent
+    module Configuration
+      class YamlSource < DottedHash
+        attr_accessor :file_path
+
+        def initialize(path, env)
+          config = {}
+          begin
+            @file_path = File.expand_path(path)
+            if !File.exists?(@file_path)
+              NewRelic::Control.instance.log.error("Unable to load configuration from #{path}")
+              return
+            end
+
+            file = File.read(@file_path)
+
+            # Next two are for populating the newrelic.yml via erb binding, necessary
+            # when using the default newrelic.yml file
+            generated_for_user = ''
+            license_key = ''
+
+            erb = ERB.new(file).result(binding)
+            config = merge!(YAML.load(erb)[env] || {})
+          rescue ScriptError, StandardError => e
+            NewRelic::Control.instance.log.warn("Unable to read configuration file: #{e}")
+          end
+
+          if config['transaction_tracer'] &&
+              config['transaction_tracer']['transaction_threshold'] =~ /apdex_f/i
+            # when value is "apdex_f" remove the config and defer to default
+            config['transaction_tracer'].delete('transaction_threshold')
+          end
+
+          booleanify_values(config, 'agent_enabled', 'enabled', 'monitor_daemons')
+
+          super(config)
+        end
+
+        protected
+
+        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
+      end
+    end
+  end
+end

data/lib/new_relic/agent/database.rb

@@ -14,27 +14,42 @@ module NewRelic
                            "Rows",
                            "Extra"
                           ].freeze
-  
+
   module Agent
     module Database
       extend self
-      
+
       def obfuscate_sql(sql)
         Obfuscator.instance.obfuscator.call(sql)
       end
-      
+
       def set_sql_obfuscator(type, &block)
         Obfuscator.instance.set_sql_obfuscator(type, &block)
       end
-      
+
+      def record_sql_method
+        case Agent.config[:'transaction_tracer.record_sql'].to_s
+        when 'off'
+          :off
+        when 'none'
+          :off
+        when 'false'
+          :off
+        when 'raw'
+          :raw
+        else
+          :obfuscated
+        end
+      end
+
       def get_connection(config)
         ConnectionManager.instance.get_connection(config)
       end
-      
+
       def close_connections
         ConnectionManager.instance.close_connections
       end
-      
+
       # Perform this in the runtime environment of a managed
       # application, to explain the sql statement executed within a
       # segment of a transaction sample. Returns an array of
@@ -50,7 +65,7 @@ module NewRelic
         explain_sql = explain_statement(statement, connection_config)
         return explain_sql || []
       end
-      
+
       def explain_statement(statement, config)
         if is_select?(statement)
           handle_exception_in_explain do
@@ -63,12 +78,12 @@ module NewRelic
           end
         end
       end
-      
+
       def process_resultset(items)
         # The resultset type varies for different drivers.  Only thing you can count on is
         # that it implements each.  Also: can't use select_rows because the native postgres
         # driver doesn't know that method.
-        
+
         headers = []
         values = []
         if items.respond_to?(:each_hash)
@@ -88,7 +103,7 @@ module NewRelic
         else
           values = [items]
         end
-        
+
         headers = nil if headers.empty?
         [headers, values]
       end
@@ -104,14 +119,14 @@ module NewRelic
           # double exception. throw up your hands
         end
       end
-      
+
       def is_select?(statement)
         # split the string into at most two segments on the
         # system-defined field separator character
         first_word, rest_of_statement = statement.split($;, 2)
         (first_word.upcase == 'SELECT')
       end
-      
+
       class ConnectionManager
         include Singleton
 
@@ -121,11 +136,11 @@ module NewRelic
         # the sql
         def get_connection(config)
           @connections ||= {}
-          
+
           connection = @connections[config]
-          
+
           return connection if connection
-          
+
           begin
             connection = ActiveRecord::Base.send("#{config[:adapter]}_connection", config)
             @connections[config] = connection
@@ -135,7 +150,7 @@ module NewRelic
             nil
           end
         end
-        
+
         # Closes all the connections in the internal connection cache
         def close_connections
           @connections ||= {}
@@ -145,16 +160,16 @@ module NewRelic
             rescue
             end
           end
-          
+
           @connections = {}
         end
       end
 
       class Obfuscator
         include Singleton
-        
+
         attr_reader :obfuscator
-        
+
         def initialize
           reset
         end
@@ -162,7 +177,7 @@ module NewRelic
         def reset
           @obfuscator = method(:default_sql_obfuscator)
         end
-        
+
         # Sets the sql obfuscator used to clean up sql when sending it
         # to the server. Possible types are:
         #
@@ -185,7 +200,7 @@ module NewRelic
             fail "unknown sql_obfuscator type #{type}"
           end
         end
-        
+
         def default_sql_obfuscator(sql)
           stmt = sql.kind_of?(Statement) ? sql : Statement.new(sql)
           adapter = stmt.adapter
@@ -215,7 +230,7 @@ module NewRelic
         end
       end
 
-      class Statement < String        
+      class Statement < String
         attr_accessor :adapter
       end
     end