newrelic_rpm 3.6.6.147 → 3.6.7.152

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

@@ -1,157 +0,0 @@
-# encoding: utf-8
-# This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
-
-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.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 determines whether the agent should try to start and
-        # report data.
-        :agent_enabled   => Proc.new do
-          self[:enabled] &&
-          (self[:developer_mode] || self[:monitor_mode] || self[:monitor_daemons]) &&
-          ::NewRelic::Agent::Autostart.agent_should_start?
-        end,
-        # Don't autostart the agent if we're in IRB or Rails console.
-        # This config option accepts a comma separated list of constants.
-        :'autostart.blacklisted_constants' => 'Rails::Console',
-        # Comma separated list of executables that you don't want to trigger
-        # agents start. e.g. 'rake,my_ruby_script.rb'
-        :'autostart.blacklisted_executables' => 'irb,rspec',
-        :'autostart.blacklisted_rake_tasks' => 'about,assets:clean,assets:clobber,assets:environment,assets:precompile,db:create,db:drop,db:fixtures:load,db:migrate,db:migrate:status,db:rollback,db:schema:cache:clear,db:schema:cache:dump,db:schema:dump,db:schema:load,db:seed,db:setup,db:structure:dump,db:version,doc:app,log:clear,middleware,notes,notes:custom,rails:template,rails:update,routes,secret,spec,spec:controllers,spec:helpers,spec:models,spec:rcov,stats,test,test:all,test:all:db,test:recent,test:single,test:uncommitted,time:zones:all,tmp:clear,tmp:create',
-        :developer_mode  => Proc.new { self[:developer] },
-        :developer       => false,
-        :apdex_t         => 0.5,
-        :monitor_daemons => false,
-        :multi_homed     => false,
-        :high_security   => false,
-        # Strip messages from all exceptions that are not specified in the whitelist.
-        :'strip_exception_messages.enabled' => Proc.new { self[:high_security] },
-        # Comma separated list of exceptions that should show messages when
-        # strip_exception_messages is enabled (e.g. 'NewException, RelicException').
-        :'strip_exception_messages.whitelist' => '',
-
-        :host                   => 'collector.newrelic.com',
-        :api_host               => 'rpm.newrelic.com',
-        :port                   => Proc.new { self[:ssl] ? 443 : 80 },
-        :api_port               => Proc.new { self[:port] },
-        :ssl                    => 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_sinatra                      => false,
-        :disable_sinatra_auto_middleware      => false,
-        :disable_view_instrumentation         => false,
-        :disable_backtrace_cleanup            => false,
-        :disable_harvest_thread               => false,
-        :skip_ar_instrumentation              => false,
-        :disable_activerecord_instrumentation => Proc.new { self[:skip_ar_instrumentation] },
-        :disable_memcache_instrumentation     => false,
-        :disable_mobile_headers               => true,
-
-        :capture_params        => false,
-        :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,Sinatra::NotFound',
-
-        :'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' },
-
-        :'request_sampler.enabled'        => true,
-        :'request_sampler.sample_rate_ms' => 50
-      ].freeze
-    end
-  end
-end

data/lib/new_relic/agent/instrumentation/browser_monitoring_timings.rb

@@ -1,56 +0,0 @@
-# encoding: utf-8
-# This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
-
-module NewRelic
-  module Agent
-    module Instrumentation
-      class BrowserMonitoringTimings
-
-        def initialize(queue_time_in_seconds, transaction)
-          @transaction = transaction
-          @now = Time.now.to_i
-          if @transaction.nil?
-            @start_time_in_seconds = 0.0
-          else
-            @transaction_name = transaction.transaction.name
-            @start_time_in_seconds = transaction.start_time.to_i
-          end
-
-          @queue_time_in_seconds = clamp_to_positive(queue_time_in_seconds)
-        end
-
-        attr_reader :transaction_name,
-                    :start_time_in_seconds, :queue_time_in_seconds
-
-        def start_time_in_millis
-          convert_to_milliseconds(@start_time_in_seconds)
-        end
-
-        def queue_time_in_millis
-          convert_to_milliseconds(queue_time_in_seconds)
-        end
-
-        def app_time_in_millis
-          convert_to_milliseconds(app_time_in_seconds)
-        end
-
-        def app_time_in_seconds
-          @now - @start_time_in_seconds
-        end
-
-        private
-
-        def convert_to_milliseconds(value_in_seconds)
-          clamp_to_positive((value_in_seconds.to_f * 1000.0).round)
-        end
-
-        def clamp_to_positive(value)
-          return 0.0 if value.nil? || value < 0
-          value
-        end
-
-      end
-    end
-  end
-end

data/lib/new_relic/agent/thread.rb

@@ -1,37 +0,0 @@
-# encoding: utf-8
-# This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
-
-module NewRelic
-  module Agent
-
-    class AgentThread < ::Thread
-      def initialize(label)
-        ::NewRelic::Agent.logger.debug("Creating New Relic thread: #{label}")
-        self[:newrelic_label] = label
-        super
-      end
-
-      def self.bucket_thread(thread, profile_agent_code)
-        if thread.key?(:newrelic_label)
-          return profile_agent_code ? :agent : :ignore
-        elsif thread[:newrelic_transaction].respond_to?(:last) &&
-            thread[:newrelic_transaction].last
-          thread[:newrelic_transaction].last.request.nil? ? :background : :request
-        else
-          :other
-        end
-      end
-
-      def self.scrub_backtrace(thread, profile_agent_code)
-        begin
-          bt = thread.backtrace
-        rescue Exception => e
-          ::NewRelic::Agent.logger.debug("Failed to backtrace #{thread.inspect}: #{e.class.name}: #{e.to_s}")
-        end
-        return nil unless bt
-        profile_agent_code ? bt : bt.select { |t| t !~ /\/newrelic_rpm-\d/ }
-      end
-    end
-  end
-end

data/lib/new_relic/agent/thread_profiler.rb

@@ -1,323 +0,0 @@
-# encoding: utf-8
-# This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
-
-require 'new_relic/agent/thread'
-require 'new_relic/agent/worker_loop'
-
-module NewRelic
-  module Agent
-
-    class ThreadProfiler
-
-      attr_reader :profile
-
-      def self.is_supported?
-        RUBY_VERSION >= "1.9.2"
-      end
-
-      def start(profile_id, duration, interval, profile_agent_code)
-        if !ThreadProfiler.is_supported?
-          ::NewRelic::Agent.logger.debug("Not starting thread profile as it isn't supported on this environment")
-          @profile = nil
-        else
-          ::NewRelic::Agent.logger.debug("Starting thread profile. profile_id=#{profile_id}, duration=#{duration}")
-          @profile = ThreadProfile.new(profile_id, duration, interval, profile_agent_code)
-          @profile.run
-        end
-      end
-
-      def stop(report_data)
-        @profile.stop unless @profile.nil?
-        @profile = nil if !report_data
-      end
-
-      def harvest
-        profile = @profile
-        @profile = nil
-        profile
-      end
-
-      def respond_to_commands(commands, &notify_results)
-        return if commands.empty? || commands.first.size < 2
-
-        # Doesn't deal with multiple commands in the return set  as
-        # we currently only have start/stop of thread profiling
-        command_id = commands.first[0]
-        command = commands.first[1]
-
-        name = command["name"]
-        arguments = command["arguments"]
-
-        if (ThreadProfiler.is_supported?)
-          case name
-            when "start_profiler"
-              start_unless_running_and_notify(command_id, arguments, &notify_results)
-
-            when "stop_profiler"
-              stop_and_notify(command_id, arguments, &notify_results)
-          end
-        else
-          msg = <<-EOF
-Thread profiling is only supported on 1.9.2 and greater versions of Ruby.
-We detected running agents capable of profiling, but the profile started with
-an agent running Ruby #{RUBY_VERSION}.
-
-Profiling again might select an appropriate agent, but we recommend running a
-consistent version of Ruby across your application for better results.
-EOF
-          ::NewRelic::Agent.logger.debug(msg)
-          notify_results.call(command_id, msg) if !notify_results.nil?
-        end
-      end
-
-      def running?
-        !@profile.nil?
-      end
-
-      def finished?
-        @profile && @profile.finished?
-      end
-
-      private
-
-      def start_unless_running_and_notify(command_id, arguments)
-        profile_id = arguments.fetch("profile_id", -1)
-        duration =   arguments.fetch("duration", 120)
-        interval =   arguments.fetch("sample_period", 0.1)
-        profile_agent_code = arguments.fetch("profile_agent_code", true)
-
-        if running?
-          msg = "Profile already in progress. Ignoring agent command to start another."
-          ::NewRelic::Agent.logger.debug(msg)
-          yield(command_id, msg) if block_given?
-        else
-          start(profile_id, duration, interval, profile_agent_code)
-          yield(command_id) if block_given?
-        end
-      end
-
-      def stop_and_notify(command_id, arguments)
-        report_data = arguments.fetch("report_data", true)
-        stop(report_data)
-        yield(command_id) if block_given?
-      end
-
-    end
-
-    class ThreadProfile
-
-      attr_reader :profile_id,
-        :traces,
-        :profile_agent_code, :interval,
-        :poll_count, :sample_count,
-        :start_time, :stop_time
-
-      def initialize(profile_id, duration, interval, profile_agent_code)
-        @profile_id = profile_id
-        @profile_agent_code = profile_agent_code
-
-        @worker_loop = NewRelic::Agent::WorkerLoop.new(:duration => duration)
-        @interval = interval
-        @finished = false
-
-        @traces = {
-          :agent => [],
-          :background => [],
-          :other => [],
-          :request => []
-        }
-        @flattened_nodes = []
-
-        @poll_count = 0
-        @sample_count = 0
-        @failure_count = 0
-      end
-
-      def run
-        AgentThread.new('Thread Profiler') do
-          @start_time = now_in_millis
-
-          @worker_loop.run(@interval) do
-            NewRelic::Agent.instance.stats_engine.
-              record_supportability_metric_timed("ThreadProfiler/PollingTime") do
-
-              @poll_count += 1
-              AgentThread.list.each do |t|
-                bucket = AgentThread.bucket_thread(t, @profile_agent_code)
-                if bucket != :ignore
-                  backtrace = AgentThread.scrub_backtrace(t, @profile_agent_code)
-                  if backtrace.nil?
-                    @failure_count += 1
-                  else
-                    @sample_count += 1
-                    aggregate(backtrace, @traces[bucket])
-                  end
-                end
-              end
-            end
-          end
-
-          mark_done
-          ::NewRelic::Agent.logger.debug("Finished thread profile. #{@sample_count} backtraces, #{@failure_count} failures. Will send with next harvest.")
-          NewRelic::Agent.instance.stats_engine.
-            record_supportability_metric_count("ThreadProfiler/BacktraceFailures", @failure_count)
-        end
-      end
-
-      def stop
-        @worker_loop.stop
-        mark_done
-        ::NewRelic::Agent.logger.debug("Stopping thread profile.")
-      end
-
-      def aggregate(trace, trees=@traces[:request], parent=nil)
-        return nil if trace.nil? || trace.empty?
-        node = Node.new(trace.last)
-        existing = trees.find {|n| n == node}
-
-        if existing.nil?
-          existing = node
-          @flattened_nodes << node
-        end
-
-        if parent
-          parent.add_child(node)
-        else
-          trees << node unless trees.include? node
-        end
-
-        existing.runnable_count += 1
-        aggregate(trace[0..-2], existing.children, existing)
-
-        existing
-      end
-
-      def prune!(count_to_keep)
-        @flattened_nodes.sort!(&:order_for_pruning)
-
-        NewRelic::Agent.instance.stats_engine.
-          record_supportability_metric_count("ThreadProfiler/NodeCount", @flattened_nodes.size)
-
-        mark_for_pruning(@flattened_nodes, count_to_keep)
-
-        traces.each { |_, nodes| Node.prune!(nodes) }
-      end
-
-      THREAD_PROFILER_NODES = 20_000
-
-      include NewRelic::Coerce
-
-      def to_collector_array(encoder)
-        prune!(THREAD_PROFILER_NODES)
-
-        traces = {
-          "OTHER" => @traces[:other].map{|t| t.to_array },
-          "REQUEST" => @traces[:request].map{|t| t.to_array },
-          "AGENT" => @traces[:agent].map{|t| t.to_array },
-          "BACKGROUND" => @traces[:background].map{|t| t.to_array }
-        }
-
-        [[
-          int(@profile_id),
-          float(@start_time),
-          float(@stop_time),
-          int(@poll_count),
-          string(encoder.encode(traces)),
-          int(@sample_count),
-          0
-        ]]
-      end
-
-      def now_in_millis
-        Time.now.to_f * 1_000
-      end
-
-      def finished?
-        @finished
-      end
-
-      def mark_done
-        @finished = true
-        @stop_time = now_in_millis
-      end
-
-      def mark_for_pruning(nodes, count_to_keep)
-        to_prune = nodes[count_to_keep..-1] || []
-        to_prune.each { |n| n.to_prune = true }
-      end
-
-      def self.flattened_nodes(nodes)
-        nodes.map { |n| [n, flattened_nodes(n.children)] }.flatten
-      end
-
-      def self.parse_backtrace(trace)
-        trace.map do |line|
-          line =~ /(.*)\:(\d+)\:in `(.*)'/
-          { :method => $3, :line_no => $2.to_i, :file => $1 }
-        end
-      end
-
-      class Node
-        attr_reader :file, :method, :line_no, :children
-        attr_accessor :runnable_count, :to_prune, :depth
-
-        def initialize(line, parent=nil)
-          line =~ /(.*)\:(\d+)\:in `(.*)'/
-          @file = $1
-          @method = $3
-          @line_no = $2.to_i
-          @children = []
-          @runnable_count = 0
-          @to_prune = false
-          @depth = 0
-
-          parent.add_child(self) if parent
-        end
-
-        def ==(other)
-          @file == other.file &&
-            @method == other.method &&
-            @line_no == other.line_no
-        end
-
-        def total_count
-          @runnable_count
-        end
-
-        # Descending order on count, ascending on depth of nodes
-        def order_for_pruning(y)
-          [-runnable_count, depth] <=> [-y.runnable_count, y.depth]
-        end
-
-        include NewRelic::Coerce
-
-        def to_array
-          [[
-              string(@file),
-              string(@method),
-              int(@line_no)
-            ],
-            int(@runnable_count),
-            0,
-            @children.map {|c| c.to_array}]
-        end
-
-        def add_child(child)
-          child.depth = @depth + 1
-          @children << child unless @children.include? child
-        end
-
-        def prune!
-          Node.prune!(@children)
-        end
-
-        def self.prune!(kids)
-          kids.delete_if { |child| child.to_prune }
-          kids.each { |child| child.prune! }
-        end
-      end
-
-    end
-  end
-end