sundawg_newrelic_rpm 3.5.8.1

data/lib/new_relic/agent/busy_calculator.rb

@@ -0,0 +1,112 @@
+module NewRelic
+  module Agent
+    # This module supports calculation of actual time spent processing requests over the course of
+    # one harvest period.  It's similar to what you would get if you just added up all the
+    # execution times of controller calls, however that will be inaccurate when requests
+    # span the minute boundaries.  This module manages accounting of requests not yet
+    # completed.
+    #
+    # Calls are re-entrant.  All start calls must be paired with finish
+    # calls, or a reset call.
+    module BusyCalculator
+
+      extend self
+
+      # For testability, add accessors:
+      attr_reader :harvest_start, :accumulator
+      
+      # sets up busy calculations based on the start and end of
+      # transactions - used for a rough estimate of what percentage of
+      # wall clock time is spent processing requests
+      def dispatcher_start(time)
+        Thread.current[:busy_entries] ||= 0
+        callers = Thread.current[:busy_entries] += 1
+        return if callers > 1
+        @lock.synchronize do
+          @entrypoint_stack.push time
+        end
+      end
+      
+      # called when a transaction finishes, to add time to the
+      # instance variable accumulator. this is harvested when we send
+      # data to the server
+      def dispatcher_finish(end_time = nil)
+        # If #dispatcher_start hasn't been called at least once, abort early
+        return unless Thread.current[:busy_entries]
+
+        end_time ||= time_now
+        callers = Thread.current[:busy_entries] -= 1
+
+        # Ignore nested calls
+        return if callers > 0
+
+        @lock.synchronize do
+          if @entrypoint_stack.empty?
+            ::NewRelic::Agent.logger.warn("Stack underflow tracking dispatcher entry and exit!\n  #{caller.join("  \n")}")
+          else
+            @accumulator += (end_time - @entrypoint_stack.pop).to_f
+          end
+        end
+      end
+      
+      # this returns the size of the entry point stack, which
+      # determines how many transactions are running
+      def busy_count
+        @entrypoint_stack.size
+      end
+
+      # Reset the state of the information accumulated by all threads,
+      # but only reset the recursion counter for this thread.
+      def reset
+        @entrypoint_stack = []
+        Thread.current[:busy_entries] = 0
+        @lock ||= Mutex.new
+        @accumulator = 0
+        @harvest_start = time_now
+      end
+
+
+      # Called before uploading to to the server to collect current busy stats.
+      def harvest_busy
+        busy = 0
+        t0 = time_now
+        @lock.synchronize do
+          busy = accumulator
+          @accumulator = 0
+
+          # Walk through the stack and capture all times up to
+          # now for entrypoints
+          @entrypoint_stack.size.times do |frame|
+            busy += (t0 - @entrypoint_stack[frame]).to_f
+            @entrypoint_stack[frame] = t0
+          end
+
+        end
+
+        busy = 0.0 if busy < 0.0 # don't go below 0%
+
+        time_window = (t0 - harvest_start).to_f
+        time_window = 1.0 if time_window == 0.0  # protect against divide by zero
+
+        busy = busy / time_window
+
+        instance_busy_stats.record_data_point busy if Agent.config[:report_instance_busy]
+        @harvest_start = t0
+      end
+
+      private
+
+      # so we can stub Time.now only for the BusyCalculator in tests
+      def time_now
+        Time.now
+      end
+
+      def instance_busy_stats
+        # Late binding on the Instance/busy stats
+        NewRelic::Agent.agent.stats_engine.get_stats_no_scope 'Instance/Busy'
+      end
+
+      self.reset
+    end
+  end
+end

data/lib/new_relic/agent/chained_call.rb

@@ -0,0 +1,13 @@
+# This class is used by NewRelic::Agent.set_sql_obfuscator to chain multiple
+# obfuscation blocks when not using the default :replace action
+class NewRelic::ChainedCall
+  def initialize(block1, block2)
+    @block1 = block1
+    @block2 = block2
+  end
+
+  def call(sql)
+    sql = @block1.call(sql)
+    @block2.call(sql)
+  end
+end

data/lib/new_relic/agent/configuration.rb

@@ -0,0 +1,74 @@
+require 'new_relic/agent/configuration/manager'
+
+# The agent's configuration is accessed through a configuration object exposed
+# by ::NewRelic::Agent.config.  It provides a hash like interface to the
+# agent's settings.
+#
+# For example:
+# ::NewRelic::Agent.config[:'transaction_tracer.enabled']
+# determines whether transaction tracing is enabled.  String and symbol keys
+# are treated indifferently and nested keys are collapsed and concatenated with
+# a dot (i.e. {:a => {:b => 'c'} becomes { 'a.b' => 'c'}).
+#
+# The agent reads configuration from a variety of sources. These sources are
+# modeled as a set of layers.  The top layer has the highest priority.  If the
+# top layer does not contain the requested setting the config object will search
+# through the subsequent layers returning the first value it finds.
+#
+# Configuration layers include EnvironmentSource (which reads settings from
+# ENV), ServerSource (which reads Server Side Config from New Relic's servers),
+# YamlSource (which reads from newrelic.yml),  ManualSource (which reads
+# arguments passed to NewRelic::Agent.manual_start or potentially other
+# methods), and Defaults (which contains default settings).
+#
+module NewRelic
+  module Agent
+    module Configuration
+      # This can be mixed in with minimal impact to provide easy
+      # access to the config manager
+      module Instance
+        def config
+          @@manager ||= Manager.new
+        end
+
+        # for testing
+        def reset_config
+          @@manager = Manager.new
+        end
+      end
+
+      class DottedHash < ::Hash
+        def initialize(hash)
+          self.merge!(dot_flattened(hash))
+          keys.each do |key|
+            self[(key.to_sym rescue key) || key] = delete(key)
+          end
+        end
+
+        def inspect
+          "#<#{self.class.name}:#{object_id} #{super}>"
+        end
+
+        def to_hash
+          {}.replace(self)
+        end
+
+        protected
+        # turns {'a' => {'b' => 'c'}} into {'a.b' => 'c'}
+        def dot_flattened(nested_hash, names=[], result={})
+          nested_hash.each do |key, val|
+            next if val == nil
+            if val.respond_to?(:has_key?)
+              dot_flattened(val, names + [key], result)
+            else
+              result[(names + [key]).join('.')] = val
+            end
+          end
+          result
+        end
+      end
+
+      class ManualSource < DottedHash; end
+    end
+  end
+end

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

@@ -0,0 +1,132 @@
+module NewRelic
+  module Agent
+    module Configuration
+      # This is so we can easily differentiate between the actual
+      # default source and a Hash that was simply pushed onto the
+      # config stack.
+      class DefaultSource < Hash; end
+
+      DEFAULTS = DefaultSource[
+        :config_path => Proc.new {
+          # Check a sequence of file locations for newrelic.yml
+          files = []
+          files << File.join("config","newrelic.yml")
+          files << File.join("newrelic.yml")
+          if ENV["HOME"]
+            files << File.join(ENV["HOME"], ".newrelic", "newrelic.yml")
+            files << File.join(ENV["HOME"], "newrelic.yml")
+          end
+          files.detect do |file|
+            File.expand_path(file) if File.exists? file
+          end
+        },
+        :app_name   => Proc.new { NewRelic::Control.instance.env },
+        :dispatcher => Proc.new { NewRelic::Control.instance.local_env.discovered_dispatcher },
+        :framework => Proc.new do
+          case
+          when defined?(::NewRelic::TEST) then :test
+          when defined?(::Merb) && defined?(::Merb::Plugins) then :merb
+          when defined?(::Rails)
+            case Rails::VERSION::MAJOR
+            when 0..2
+              :rails
+            when 3
+              :rails3
+            when 4
+              :rails4
+            else
+              ::NewRelic::Agent::Agent.logger.error "Detected unsupported Rails version #{Rails::VERSION::STRING}"
+            end
+          when defined?(::Sinatra) && defined?(::Sinatra::Base) then :sinatra
+          when defined?(::NewRelic::IA) then :external
+          else :ruby
+          end
+        end,
+        :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::Agent.config[: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                    => true,
+        :verify_certificate     => true,
+        :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,
+        :report_instance_busy   => true,
+
+        :log_file_name => 'newrelic_agent.log',
+        :log_file_path => 'log/',
+        :log_level     => 'info',
+
+        :'audit_log.enabled'      => false,
+        :'audit_log.path'         => Proc.new {
+          File.join(self[:log_file_path], 'newrelic_audit.log')
+        },
+
+        :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'] },
+
+        :trusted_account_ids                => [],
+        :"cross_application_tracer.enabled" => true,
+
+        :'thread_profiler.enabled' => Proc.new { NewRelic::Agent::ThreadProfiler.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,49 @@
+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_HOST'        => :host,
+            'NEW_RELIC_PORT'        => :port
+          }.each do |key, val|
+            self[val] = ENV[key] if ENV[key]
+          end
+
+          symbol_map = {
+            'NEW_RELIC_DISPATCHER'  => :dispatcher,
+            'NEWRELIC_DISPATCHER'   => :dispatcher,
+            'NEW_RELIC_FRAMEWORK'   => :framework,
+            'NEWRELIC_FRAMEWORK'    => :framework
+          }.each do |key, val|
+            self[val] = ENV[key].intern 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
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,148 @@
+require 'forwardable'
+require 'new_relic/agent/configuration/defaults'
+require 'new_relic/agent/configuration/mask_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)
+          was_finished = finished_configuring?
+
+          invoke_callbacks(:add, source)
+          @config_stack.insert(level, source.freeze)
+          reset_cache
+          log_config(:add, source)
+
+          notify_finished_configuring if !was_finished && finished_configuring?
+        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)
+          log_config(: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 notify_finished_configuring
+          NewRelic::Agent.instance.events.notify(:finished_configuring)
+        end
+
+        def finished_configuring?
+          @config_stack.any? {|s| s.is_a?(ServerSource)}
+        end
+
+        def flattened
+          @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::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)
+          end
+        end
+
+        def apply_mask(hash)
+          MASK_DEFAULTS. \
+            select {|_, proc| proc.call}. \
+            each {|key, _| hash.delete(key) }
+          hash
+        end
+
+        def to_collector_hash
+          DottedHash.new(apply_mask(flattened)).to_hash
+        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
+
+        def log_config(direction, source)
+          ::NewRelic::Agent.logger.debug(
+            "Updating config (#{direction}) from #{source.class}. Results:",
+            flattened.inspect)
+        end
+      end
+    end
+  end
+end