newrelic_rpm 3.12.0.288 → 9.10.2

data/config/database.yml

@@ -1,5 +0,0 @@
-# This config is used when setting up a basic rails environment for running the
-# unit tests.
-test:
-  database: ':memory:'
-  adapter: 'sqlite3'

data/config.dot

@@ -1,287 +0,0 @@
-digraph AgentEnabled {
-  node[color=green]
-  "[agent_enabled]"
-  "[developer_mode]"
-  "[monitor_mode]"
-  "[slow_sql.explain_threshold]"
-  "[slow_sql.stack_trace_threshold]"
-  "[slow_sql.explain_enabled]"
-  "[slow_sql.enabled]"
-  "[slow_sql.record_sql]"
-  "[transaction_tracer.limit_segments]"
-  "[transaction_tracer.stack_trace_threshold]"
-  "[transaction_tracer.explain_threshold]"
-  "[transaction_tracer.explain_enabled]"
-  "[transaction_tracer.transaction_threshold]"
-  "[transaction_tracer.record_sql]"
-  "[transaction_tracer.random_sample]"
-  "[transaction_tracer.enabled]"
-  "[error_collector.capture_source]"
-  "[error_collector.enabled]"
-  "[error_collector.ignore_errors]"
-  "[browser_monitoring.auto_instrument]"
-  "[license_key]"
-  "[ssl]"
-  "[verify_certificate]"
-  "[api_host]"
-  "[api_port]"
-  "[proxy_host]"
-  "[proxy_port]"
-  "[proxy_user]"
-  "[proxy_pass]"
-  "[host]"
-  "[port]"
-  "[timeout]"
-  "[log_level]"
-  "[apdex_t]"
-  "[capture_params]"
-  "[app_name]"
-  "[multi_homed]"
-  "[disable_samplers]"
-  "[log_file_name]"
-  "[log_file_path]"
-  "[dispatcher]"
-  "[force_send]"
-  "[textmate]"
-  "[post_size_limit]"
-  "[sync_startup]"
-  "[send_data_on_exit]"
-  "[high_security]"
-  "[validate_seed]"
-  "[validate_token]"
-  "[disable_backtrace_cleanup]"
-  "[disable_activerecord_instrumentation]"
-  "[disable_dj]"
-  "[capture_memcache_keys]"
-  "[disable_memcache_instrumentation]"
-  "[disable_view_instrumentation]"
-  "[disable_resque]"
-
-  node[shape=box,color=orange]
-  "Control#init_plugin"
-  "Control#api_server"
-  "Control#proxy_server"
-  "Control#server_from_host"
-  "Control#http_connection"
-  "Control#set_log_level!"
-  "Control#log_path"
-  "Control#log_to_stdout?"
-  "Control#convert_to_ip_address"
-  "Control#server"
-  "Control#setup_log"
-  "Control#should_log?"
-  "Control#log!"
-
-  node[color=green]
-  "Config#app_names"
-
-  node[color=black]
-  "Agent#initialize"
-  "Agent#after_fork"
-  "Agent#disabled?"
-  "Agent#shutdown"
-  "Agent#using_forking_dispatcher?"
-  "Agent#has_license_key?"
-  "Agent#correct_license_length"
-  "Agent#apdex_f"
-  "Agent#check_config_and_start_agent"
-  "Agent#install_exit_handler"
-  "Agent#log_app_names"
-  "Agent#connect_settings"
-  "Agent#log_seed_token"
-  "Agent#log_error"
-  "Agent#monitoring?"
-  "Agent#check_trasaction_sampler_status"
-  "Agent#check_sql_sampler_status"
-  "Agent#config_transaction_tracer"
-  "Agent#set_sql_recording!"
-  "Agent#already_started?"
-  "Agent#log_connection"
-  "Agent#manual_start"
-
-  "MethodTracer#remove_method_tracer"
-
-  "ErrorCollector#initialize"
-  "ErrorCollector#request_params_from_opts"
-
-  "ControllerInstrumentation#perform_action_with_newrelic_trace"
-
-  "NewRelicService#initialize"
-  "NewRelicService#check_post_size"
-  "NewRelicService#connect"
-  "NewRelicService#send_request"
-
-  "SqlSampler#configure!"
-
-  "TransactionSampler#configure!"
-  "TransactionSampler#notice_push_scope"
-  "TransactionSampler#capture_segment_trace"
-  "TransactionSampler#store_segment_for_developer_mode"
-
-  "NoticedError#initialize"
-
-  "BeaconConfiguration#license_bytes"
-
-  "ActiveRecord#depends_on"
-  "DelayedJobInstrumentation#depends_on"
-  "Memcache#memcache_key_snippet"
-  "Memcache#depends_on"
-  "Rails::ActionController#depends_on"
-  "Rails3::ActionController#depends_on"
-  "Resque#depends_on"
-
-  "DelayedJobSampler#initialize"
-  "DelayedJobInjection#depends_on"
-
-  "MetricFrame.update_apdex"
-
-  "TranactionInfo#force_persist_sample?"
-  "TranactionInfo#include_guid?"
-
-  "TransactionSampleBuilder#initialize"
-  "TransactionSampleBuilder#set_transaction_info"
-
-  "Rails#install_browser_monitoring"
-  "Rails#log!"
-  "Rails3#log!"
-
-  "CollectionHelper#strip_nr_from_backtrace"
-
-  "Deployments#initialize"
-
-#######
-
-  "Control#init_plugin" -> "[agent_enabled]"
-  "Control#init_plugin" -> "Control#setup_log"
-  "Control#init_plugin" -> "[disable_samplers]"
-  "Control#should_log?" -> "[agent_enabled]"
-  "Control#api_server" -> "[api_host]"
-  "Control#api_server" -> "[api_port]"
-  "Control#proxy_server" -> "[proxy_host]"
-  "Control#proxy_server" -> "[proxy_port]"
-  "Control#proxy_server" -> "[proxy_user]"
-  "Control#proxy_server" -> "[proxy_pass]"
-  "Control#server_from_host" -> "[host]"
-  "Control#server_from_host" -> "[port]"
-  "Control#server_from_host" -> "Control#convert_to_ip_address"
-  "Control#http_connection" -> "[ssl]"
-  "Control#http_connection" -> "[verify_certificate]"
-  "Control#http_connection" -> "Control#proxy_server"
-  "Control#set_log_level!" -> "[log_level]"
-  "Control#log_path" -> "[log_file_path]"
-  "Control#log_path" -> "Control#log_to_stdout?"
-  "Control#log_to_stdout?" -> "[log_file_path]"
-  "Control#convert_to_ip_address" -> "[ssl]"
-  "Control#convert_to_ip_address" -> "[verify_certificate]"
-  "Control#server" -> "Control#server_from_host"
-  "Control#setup_log" -> "Control#set_log_level!"
-  "Control#setup_log" -> "Control#log_path"
-  "Control#setup_log" -> "Control#log_to_stdout?"
-  "Control#setup_log" -> "[log_file_name]"
-  "Control#log!" -> "Control#should_log?"
-  "Control#log!" -> "Control#log_path"
-
-  "Agent#initialize" -> "[monitor_mode]"
-  "Agent#after_fork" -> "[agent_enabled]"
-  "Agent#after_fork" -> "[monitor_mode]"
-  "Agent#disabled?" -> "[agent_enabled]"
-  "Agent#shutdown" -> "[force_send]"
-  "Agent#shutdown" -> "[dispatcher]"
-  "Agent#using_forking_dispatcher?" -> "[dispatcher]"
-  "Agent#has_license_key?" -> "[license_key]"
-  "Agent#correct_license_length" -> "[license_key]"
-  "Agent#apdex_f" -> "[apdex_t]"
-  "Agent#check_config_and_start_agent" -> "[sync_startup]"
-  "Agent#install_exit_handler" -> "[send_data_on_exit]"
-  "Agent#log_app_names" -> "Config#app_names"
-  "Agent#connect_settings" -> "Config#app_names"
-  "Agent#log_seed_token" -> "[validate_seed]"
-  "Agent#log_seed_token" -> "[validate_token]"
-  "Agent#validate_settings" -> "[validate_seed]"
-  "Agent#validate_settings" -> "[validate_token]"
-  "Agent#log_error" -> "Control#server"
-  "Agent#monitoring?" -> "[monitor_mode]"
-  "Agent#check_trasaction_sampler_status" -> "[developer_mode]"
-  "Agent#check_sql_sampler_status" -> "[slow_sql.enabled]"
-  "Agent#check_sql_sampler_status" -> "[slow_sql.record_sql]"
-  "Agent#check_sql_sampler_status" -> "[transaction_tracer.enabled]"
-  "Agent#config_transaction_tracer" -> "[transaction_tracer.enabled]"
-  "Agent#config_transaction_tracer" -> "[transaction_tracer.random_sample]"
-  "Agent#config_transaction_tracer" -> "[transaction_tracer.transaction_threshold]"
-  "Agent#set_sql_recording!" -> "[transaction_tracer.record_sql]"
-  "Agent#already_started?" -> "Control#log!"
-  "Agent#log_connection" -> "Control#log!"
-  "Agent#manual_start" -> "Control#init_plugin"
-
-  "MethodTracer#remove_method_tracer" -> "[agent_enabled]"
-
-  "Rails#init_config" -> "[agent_enabled]"
-  "Rails#init_config" -> "[developer_mode]"
-
-  "ErrorCollector#initialize" -> "[error_collector.enabled]"
-  "ErrorCollector#initialize" -> "[error_collector.capture_source]"
-  "ErrorCollector#initialize" -> "[error_collector.ignore_errors]"
-  "ErrorCollector#request_params_from_opts" -> "[capture_params]"
-
-  "NewRelicService#initialize" -> "[timeout]"
-  "NewRelicService#initialize" -> "[license_key]"
-  "NewRelicService#initialize" -> "Control#server"
-  "NewRelicService#check_post_size" -> "[post_size_limit]"
-  "NewRelicService#connect" -> "Control#server_from_host"
-  "NewRelicService#send_request" -> "Control#http_connection"
-
-  "SqlSampler#configure!" -> "[slow_sql.explain_threshold]"
-  "SqlSampler#configure!" -> "[slow_sql.explain_enabled]"
-  "SqlSampler#configure!" -> "[slow_sql.stack_trace_threshold]"
-  "SqlSampler#configure!" -> "[slow_sql.enabled]"
-
-  "TransactionSampler#configure!" -> "[transaction_tracer.limit_segments]"
-  "TransactionSampler#configure!" -> "[transaction_tracer.stack_trace_threshold]"
-  "TransactionSampler#configure!" -> "[transaction_tracer.explain_threshold]"
-  "TransactionSampler#configure!" -> "[transaction_tracer.explain_enabled]"
-  "TransactionSampler#configure!" -> "[transaction_tracer.transaction_threshold]"
-  "TransactionSampler#configure!" -> "[developer_mode]"
-  "TransactionSampler#notice_push_scope" -> "[developer_mode]"
-  "TransactionSampler#capture_segment_trace" -> "[developer_mode]"
-  "TransactionSampler#store_segment_for_developer_mode" -> "[developer_mode]"
-
-  "NoticedError#initialize" -> "[high_security]"
-
-  "BeaconConfiguration#license_bytes" -> "[license_key]"
-
-  "ActiveRecord#depends_on" -> "[disable_activerecord_instrumentation]"
-
-  "DelayedJobInstrumentation#depends_on" -> "[disable_dj]"
-
-  "Memcache#memcache_key_snippet" -> "[capture_memcache_keys]"
-  "Memcache#depends_on" -> "[disable_memcache_instrumentation]"
-
-  "Rails::ActionController#depends_on" -> "[disable_view_instrumentation]"
-  "Rails3::ActionController#depends_on" -> "[disable_view_instrumentation]"
-  "Resque#depends_on" -> "[disable_resque]"
-
-  "DelayedJobSampler#initialize" -> "[disable_dj]"
-  "DelayedJobInjection#depends_on" -> "[disable_dj]"
-  "DelayedJobInjection#executes" -> "Control#init_plugin"
-
-  "MetricFrame.update_apdex" -> "[apdex_t]"
-
-  "TranactionInfo#force_persist_sample?" -> "[apdex_t]"
-  "TranactionInfo#include_guid?" -> "[apdex_t]"
-
-  "TransactionSampleBuilder#initialize" -> "[transaction_tracer.limit_segments]"
-  "TransactionSampleBuilder#set_transaction_info" -> "[capture_params]"
-
-  "Rails#install_browser_monitoring" -> "[browser_monitoring.auto_instrument]"
-  "Rails#log!" -> "Control#should_log?"
-  "Rails3#log!" -> "Control#should_log?"
-
-  "CollectionHelper#strip_nr_from_backtrace" -> "[disable_backtrace_cleanup]"
-
-  "Deployments#initialize" -> "Config#app_names"
-  "Deployments#run" -> "Control#http_connection"
-  "Deployments#run" -> "[license_key]"
-  "Deployments#run" -> "Control#api_server"
-
-  "Config#app_names" -> "[app_name]"
-}

data/lib/conditional_vendored_dependency_detection.rb

@@ -1,7 +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.
-
-path = File.expand_path('../vendor/gems/dependency_detection-0.0.1.build/lib', File.dirname(__FILE__))
-$LOAD_PATH << path unless $LOAD_PATH.include?(path)
-require 'dependency_detection'

data/lib/conditional_vendored_metric_parser.rb

@@ -1,9 +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.
-
-unless defined?(NewRelic) && defined?(NewRelic::MetricParser)
-  vendored_metric_parser = File.expand_path('../../vendor/gems/metric_parser-0.1.0.pre1/lib/', __FILE__)
-  $:.unshift vendored_metric_parser unless $:.include?(vendored_metric_parser)
-  require 'metric_parser'
-end

data/lib/new_relic/agent/busy_calculator.rb

@@ -1,117 +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/transaction_state'
-
-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_LOCAL_ACCESS
-        state = TransactionState.tl_get
-        state.busy_entries ||= 0
-        callers = state.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) #THREAD_LOCAL_ACCESS
-        state = TransactionState.tl_get
-        # If #dispatcher_start hasn't been called at least once, abort early
-        return unless state.busy_entries
-
-        end_time ||= time_now
-        callers = state.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 #THREAD_LOCAL_ACCESS
-        @entrypoint_stack = []
-        TransactionState.tl_get.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
-
-        if Agent.config[:report_instance_busy]
-          NewRelic::Agent.record_metric('Instance/Busy', busy)
-        end
-        @harvest_start = t0
-      end
-
-      private
-
-      # so we can stub Time.now only for the BusyCalculator in tests
-      def time_now
-        Time.now
-      end
-
-      self.reset
-    end
-  end
-end

data/lib/new_relic/agent/commands/xray_session.rb

@@ -1,55 +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 'forwardable'
-
-module NewRelic
-  module Agent
-    module Commands
-      class XraySession
-        extend Forwardable
-
-        attr_reader :id, :command_arguments
-        attr_reader :xray_session_name, :key_transaction_name,
-                    :requested_trace_count, :duration, :sample_period
-
-        def initialize(command_arguments)
-          @command_arguments     = command_arguments
-          @id                    = command_arguments.fetch("x_ray_id", nil)
-          @xray_session_name     = command_arguments.fetch("xray_session_name", "")
-          @key_transaction_name  = command_arguments.fetch("key_transaction_name", "")
-          @requested_trace_count = command_arguments.fetch("requested_trace_count", 100)
-          @duration              = command_arguments.fetch("duration", 86400)
-          @sample_period         = command_arguments.fetch("sample_period", 0.1)
-          @run_profiler          = command_arguments.fetch("run_profiler", true)
-        end
-
-        def active?
-          @active
-        end
-
-        def run_profiler?
-          @run_profiler && NewRelic::Agent.config[:'xray_session.allow_profiles']
-        end
-
-        def activate
-          @active = true
-          @start_time = Time.now
-        end
-
-        def deactivate
-          @active = false
-        end
-
-        def requested_period
-          @sample_period
-        end
-
-        def finished?
-          @start_time + @duration < Time.now
-        end
-      end
-    end
-  end
-end

data/lib/new_relic/agent/commands/xray_session_collection.rb

@@ -1,161 +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 'forwardable'
-require 'thread'
-require 'new_relic/agent/commands/xray_session'
-
-module NewRelic
-  module Agent
-    module Commands
-      class XraySessionCollection
-        extend Forwardable
-
-        def initialize(backtrace_service, event_listener)
-          @backtrace_service = backtrace_service
-
-          # This lock protects access to the sessions hash, but it's expected
-          # that individual session objects within the hash will be manipulated
-          # outside the lock.  This is safe because manipulation of the session
-          # objects is expected from only a single thread (the harvest thread)
-          @sessions_lock = Mutex.new
-          @sessions = {}
-
-          if event_listener
-            event_listener.subscribe(:before_harvest, &method(:cleanup_finished_sessions))
-          end
-        end
-
-        def handle_active_xray_sessions(agent_command)
-          # If X-Rays are disabled, just be quiet about it and don't start the
-          # command. Other hosts might be running the X-Ray, so we don't need
-          # to bark on every get_agent_commands.
-          if !NewRelic::Agent.config[:'xray_session.enabled']
-            NewRelic::Agent.logger.debug("Not responding to X-Ray command because of config 'xray_session.enabled' = #{NewRelic::Agent.config[:'xray_session.enabled']}")
-            return
-          end
-
-          incoming_ids = agent_command.arguments["xray_ids"]
-          deactivate_for_incoming_sessions(incoming_ids)
-          activate_sessions(incoming_ids)
-        end
-
-        def session_id_for_transaction_name(name)
-          @sessions_lock.synchronize do
-            @sessions.each do |id, session|
-              return id if session.key_transaction_name == name
-            end
-          end
-          nil
-        end
-
-        NO_PROFILES = [].freeze
-
-        def harvest_thread_profiles
-          return NO_PROFILES unless NewRelic::Agent::Threading::BacktraceService.is_supported?
-
-          profiles = active_thread_profiling_sessions.map do |session|
-            NewRelic::Agent.logger.debug("Harvesting profile for X-Ray session #{session.inspect}")
-            @backtrace_service.harvest(session.key_transaction_name)
-          end
-          profiles.reject! {|p| p.empty?}
-          profiles.compact
-        end
-
-        def stop_all_sessions
-          deactivate_for_incoming_sessions([])
-        end
-
-        def cleanup_finished_sessions
-          finished_session_ids.each do |id|
-            NewRelic::Agent.logger.debug("Finished X-Ray session #{id} by duration. Removing it from active sessions.")
-            remove_session_by_id(id)
-          end
-        end
-
-
-        ### Internals
-
-        def new_relic_service
-          NewRelic::Agent.instance.service
-        end
-
-        # These are unsynchonized and should only be used for testing
-        def_delegators :@sessions, :[], :include?
-
-        def active_thread_profiling_sessions
-          @sessions_lock.synchronize do
-            @sessions.values.select { |s| s.active? && s.run_profiler? }
-          end
-        end
-
-        ### Session activation
-
-        def activate_sessions(incoming_ids)
-          lookup_metadata_for(ids_to_activate(incoming_ids)).each do |raw|
-            add_session(XraySession.new(raw))
-          end
-        end
-
-        def ids_to_activate(incoming_ids)
-          @sessions_lock.synchronize { incoming_ids - @sessions.keys }
-        end
-
-        # Please don't hold the @sessions_lock across me! Calling the service
-        # is time-consuming, and will block request threads. Which is rude.
-        def lookup_metadata_for(ids_to_activate)
-          return [] if ids_to_activate.empty?
-
-          NewRelic::Agent.logger.debug("Retrieving metadata for X-Ray sessions #{ids_to_activate.inspect}")
-          new_relic_service.get_xray_metadata(ids_to_activate)
-        end
-
-        def add_session(session)
-          NewRelic::Agent.logger.debug("Adding X-Ray session #{session.inspect}")
-          NewRelic::Agent.increment_metric("Supportability/XraySessions/Starts")
-
-          @sessions_lock.synchronize { @sessions[session.id] = session }
-
-          session.activate
-          if session.run_profiler?
-            @backtrace_service.subscribe(session.key_transaction_name, session.command_arguments)
-          end
-        end
-
-        ### Session deactivation
-
-        def deactivate_for_incoming_sessions(incoming_ids)
-          ids_to_remove(incoming_ids).each do |session_id|
-            remove_session_by_id(session_id)
-          end
-        end
-
-        def ids_to_remove(incoming_ids)
-          @sessions_lock.synchronize { @sessions.keys - incoming_ids }
-        end
-
-        def remove_session_by_id(id)
-          session = @sessions_lock.synchronize { @sessions.delete(id) }
-
-          if session
-            NewRelic::Agent.logger.debug("Removing X-Ray session #{session.inspect}")
-            NewRelic::Agent.increment_metric("Supportability/XraySessions/Stops")
-
-            if session.run_profiler?
-              @backtrace_service.unsubscribe(session.key_transaction_name)
-            end
-            session.deactivate
-          end
-        end
-
-        def finished_session_ids
-          @sessions_lock.synchronize do
-            @sessions.map{|k, s| k if s.finished?}.compact
-          end
-        end
-
-      end
-    end
-  end
-end