newrelic_rpm 3.12.0.288 → 3.12.1.298

data/lib/new_relic/agent/transaction/attributes.rb

@@ -110,6 +110,8 @@ module NewRelic
         end
 
         def add(attributes, key, value)
+          return unless value
+
           if exceeds_bytesize_limit?(value, VALUE_LIMIT)
             value = slice(value)
           end

data/lib/new_relic/agent/transaction/trace_node.rb

@@ -169,7 +169,7 @@ module NewRelic
 
           NewRelic::Agent::Database.explain_sql(statement,
                                                 statement.config,
-                                                &statement.explainer)
+                                                statement.explainer)
         end
 
         def obfuscated_sql

data/lib/new_relic/agent/transaction_event_aggregator.rb

@@ -20,7 +20,6 @@ class NewRelic::Agent::TransactionEventAggregator
   TIMESTAMP_KEY                  = 'timestamp'.freeze
   NAME_KEY                       = 'name'.freeze
   DURATION_KEY                   = 'duration'.freeze
-  HTTP_RESPONSE_CODE_KEY         = 'httpResponseCode'.freeze
   GUID_KEY                       = 'nr.guid'.freeze
   REFERRING_TRANSACTION_GUID_KEY = 'nr.referringTransactionGuid'.freeze
   CAT_TRIP_ID_KEY                = 'nr.tripId'.freeze
@@ -161,7 +160,7 @@ class NewRelic::Agent::TransactionEventAggregator
     if main_event.include?(SYNTHETICS_RESOURCE_ID_KEY)
       # Try adding to synthetics buffer. If anything is rejected, give it a
       # shot in the main transaction events (where it may get sampled)
-      result, rejected = @synthetics_samples.append_with_reject(event)
+      _, rejected = @synthetics_samples.append_with_reject(event)
 
       if rejected
         @samples.append(rejected)
@@ -228,17 +227,10 @@ class NewRelic::Agent::TransactionEventAggregator
     optionally_append(SYNTHETICS_RESOURCE_ID_KEY,     :synthetics_resource_id, sample, payload)
     optionally_append(SYNTHETICS_JOB_ID_KEY,          :synthetics_job_id, sample, payload)
     optionally_append(SYNTHETICS_MONITOR_ID_KEY,      :synthetics_monitor_id, sample, payload)
-    append_http_response_code(sample, payload)
     append_cat_alternate_path_hashes(sample, payload)
     sample
   end
 
-  def append_http_response_code(sample, payload)
-    unless NewRelic::Agent.config[:disable_middleware_instrumentation]
-      optionally_append(HTTP_RESPONSE_CODE_KEY, :http_response_code, sample, payload)
-    end
-  end
-
   def append_cat_alternate_path_hashes(sample, payload)
     if payload.include?(:cat_alternate_path_hashes)
       sample[CAT_ALTERNATE_PATH_HASHES_KEY] = payload[:cat_alternate_path_hashes].sort.join(',')

data/lib/new_relic/agent/transaction_sample_builder.rb

@@ -3,7 +3,6 @@
 # See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
 
 require 'new_relic/collection_helper'
-require 'new_relic/control'
 require 'new_relic/agent/transaction'
 require 'new_relic/agent/transaction/trace'
 
@@ -137,11 +136,6 @@ module NewRelic
 
         depth
       end
-
-      def sample
-        @sample
-      end
-
     end
   end
 end

data/lib/new_relic/agent/transaction_sampler.rb

@@ -2,8 +2,6 @@
 # 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'
-require 'new_relic/control'
 require 'new_relic/agent/transaction_sample_builder'
 require 'new_relic/agent/transaction/developer_mode_sample_buffer'
 require 'new_relic/agent/transaction/slowest_sample_buffer'
@@ -22,15 +20,6 @@ module NewRelic
     #
     # @api public
     class TransactionSampler
-
-      # Module defining methods stubbed out when the agent is disabled
-      module Shim #:nodoc:
-        def on_start_transaction(*args); end
-        def notice_push_frame(*args); end
-        def notice_pop_frame(*args); end
-        def on_finishing_transaction(*args); end
-      end
-
       attr_reader :last_sample, :dev_mode_sample_buffer, :xray_sample_buffer
 
       def initialize
@@ -71,7 +60,6 @@ module NewRelic
       def on_start_transaction(state, start_time)
         if enabled?
           start_builder(state, start_time.to_f)
-          builder = state.transaction_sample_builder
         end
       end
 
@@ -195,7 +183,7 @@ module NewRelic
       # @api public
       # @deprecated Use {Datastores.notice_sql} instead.
       #
-      def notice_sql(sql, config, duration, state=nil, &explainer) #THREAD_LOCAL_ACCESS sometimes
+      def notice_sql(sql, config, duration, state=nil, explainer=nil) #THREAD_LOCAL_ACCESS sometimes
         # some statements (particularly INSERTS with large BLOBS
         # may be very large; we should trim them to a maximum usable length
         state ||= TransactionState.tl_get

data/lib/new_relic/agent/utilization_data.rb

@@ -2,19 +2,12 @@
 # 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/aws_info'
+
 module NewRelic
   module Agent
     class UtilizationData
-
-      REMOTE_DATA_VALID_CHARS = /^[0-9a-zA-Z_ .\/-]$/.freeze
-
-      def harvest!
-        [hostname, container_id, cpu_count, instance_type]
-      end
-
-      # No persistent data, so no need for merging or resetting
-      def merge!(*_); end
-      def reset!(*_); end
+      METADATA_VERSION = 1
 
       def hostname
         NewRelic::Agent::Hostname.get
@@ -29,49 +22,43 @@ module NewRelic
         ::NewRelic::Agent::SystemInfo.num_logical_processors
       end
 
-      def instance_type
-        Timeout::timeout(1) do
-          remote_fetch('instance-type')
-        end
-      rescue Timeout::Error
-        NewRelic::Agent.logger.debug("UtilizationData timed out fetching remote keys.")
-        nil
-      rescue StandardError, LoadError => e
-        NewRelic::Agent.logger.debug("UtilizationData encountered error fetching remote keys:\n#{e}")
-        nil
+      def ram_in_mib
+        ::NewRelic::Agent::SystemInfo.ram_in_mib
       end
 
-      INSTANCE_HOST = '169.254.169.254'
-      API_VERSION   = '2008-02-01'
-
-      def remote_fetch(remote_key)
-        uri = URI("http://#{INSTANCE_HOST}/#{API_VERSION}/meta-data/#{remote_key}")
-        request = Net::HTTP::get(uri)
+      def to_collector_hash
+        result = {
+          :metadata_version => METADATA_VERSION,
+          :logical_processors => cpu_count,
+          :total_ram_mib => ram_in_mib,
+          :hostname => hostname
+        }
 
-        data = validate_remote_data(request)
+        append_aws_info(result)
+        append_docker_info(result)
 
-        if request && data.nil?
-          NewRelic::Agent.logger.warn("Fetching instance metadata for #{remote_key.inspect} returned invalid data: #{request.inspect}")
-        end
-
-        data
+        result
       end
 
-      def validate_remote_data(data_str)
-        return nil unless data_str.kind_of?(String)
-        return nil unless data_str.size <= 255
+      def append_aws_info(collector_hash)
+        return unless Agent.config[:'utilization.detect_aws']
 
-        data_str.each_char do |ch|
-          next if ch =~ REMOTE_DATA_VALID_CHARS
-          code_point = ch[0].ord # this works in Ruby 1.8.7 - 2.1.2
-          next if code_point >= 0x80
+        aws_info = AWSInfo.new
 
-          return nil # it's in neither set of valid characters
+        if aws_info.loaded?
+          collector_hash[:vendors] ||= {}
+          collector_hash[:vendors][:aws] = aws_info.to_collector_hash
         end
-
-        data_str
       end
 
+      def append_docker_info(collector_hash)
+        return unless Agent.config[:'utilization.detect_docker']
+
+        if docker_container_id = container_id
+          collector_hash[:vendors] ||= {}
+          collector_hash[:vendors][:docker] = {:id => docker_container_id}
+        end
+      end
     end
   end
 end

data/lib/new_relic/agent/worker_loop.rb

@@ -3,6 +3,7 @@
 # See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
 
 require 'thread'
+
 module NewRelic
   module Agent
 
@@ -76,9 +77,7 @@ module NewRelic
         @should_run = false
       end
 
-      # Executes the block given to the worker loop, and handles many
-      # possible errors. Also updates the execution time so that the
-      # next run occurs on schedule, even if we execute at some odd time
+      # Executes the block given to the worker loop, and handles errors.
       def run_task
         if @propagate_errors
           @task.call

data/lib/new_relic/cli/commands/deployments.rb

@@ -44,6 +44,11 @@ class NewRelic::Cli::Deployments < NewRelic::Cli::Command
 
   def load_yaml_from_env(env)
     yaml = NewRelic::Agent::Configuration::YamlSource.new(NewRelic::Agent.config[:config_path], env)
+    if yaml.failed?
+      messages = yaml.failures.flatten.map(&:to_s).join("\n")
+      raise NewRelic::Cli::Command::CommandFailure.new("Error in loading newrelic.yml.\n#{messages}")
+    end
+
     NewRelic::Agent.config.replace_or_add_config(yaml)
   end
 

data/lib/new_relic/coerce.rb

@@ -46,7 +46,7 @@ module NewRelic
 
     def scalar(val)
       case val
-      when String, Integer, TrueClass, FalseClass
+      when String, Integer, TrueClass, FalseClass, NilClass
         val
       when Float
         if val.finite?

data/lib/new_relic/collection_helper.rb

@@ -2,8 +2,6 @@
 # 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/control'
-
 module NewRelic
   module CollectionHelper
   DEFAULT_TRUNCATION_SIZE=16 * 1024

data/lib/new_relic/control/instance_methods.rb

@@ -68,7 +68,6 @@ module NewRelic
         Module.send :include, NewRelic::Agent::MethodTracer
         init_config(options)
         NewRelic::Agent.agent = NewRelic::Agent::Agent.instance
-        NewRelic::Agent.agent.start_service_if_needed
         if Agent.config[:agent_enabled] && !NewRelic::Agent.instance.started?
           start_agent
           install_instrumentation
@@ -144,7 +143,11 @@ module NewRelic
 
       def initialize(local_env, config_file_override=nil)
         @local_env = local_env
+        @started_in_env = nil
+
+        @instrumented = nil
         @instrumentation_files = []
+
         @config_file_override = config_file_override
       end
 

data/lib/new_relic/control/instrumentation.rb

@@ -23,16 +23,8 @@ module NewRelic
         end
       end
 
-      # Install stubs to the proper location so the app code will not fail
-      # if the agent is not running.
       def install_shim
-        # Once we install instrumentation, you can't undo that by installing the shim.
-        if @instrumented
-          NewRelic::Agent.logger.error "Cannot install the Agent shim after instrumentation has already been installed!"
-          NewRelic::Agent.logger.error caller.join("\n")
-        else
-          NewRelic::Agent.agent = NewRelic::Agent::ShimAgent.instance
-        end
+        # implemented only in subclasses
       end
 
       # Add instrumentation.  Don't call this directly.  Use NewRelic::Agent#add_instrumentation.

data/lib/new_relic/control/server_methods.rb

@@ -6,15 +6,12 @@ module NewRelic
   class Control
 
     # Structs holding info for the remote server and proxy server
-    class Server < Struct.new :name, :port, :ip #:nodoc:
+    class Server < Struct.new :name, :port #:nodoc:
       def to_s; "#{name}:#{port}"; end
     end
 
-    ProxyServer = Struct.new :name, :port, :user, :password #:nodoc:
-
     # Contains methods that deal with connecting to the server
     module ServerMethods
-
       def server
         @remote_server ||= server_from_host(nil)
       end
@@ -22,61 +19,11 @@ module NewRelic
       # the server we should contact for api requests, like uploading
       # deployments and the like
       def api_server
-        @api_server ||= NewRelic::Control::Server.new(Agent.config[:api_host], Agent.config[:api_port], nil)
+        @api_server ||= NewRelic::Control::Server.new(Agent.config[:api_host], Agent.config[:api_port])
       end
 
-      # a new instances of the proxy server - this passes through if
-      # there is no proxy, otherwise it has proxy configuration
-      # information pulled from the config file
-      def proxy_server
-        @proxy_server ||= NewRelic::Control::ProxyServer.new(Agent.config[:proxy_host],
-                                                             Agent.config[:proxy_port],
-                                                             Agent.config[:proxy_user],
-                                                             Agent.config[:proxy_pass])
-      end
-
-      # turns a hostname into an ip address and returns a
-      # NewRelic::Control::Server that contains the configuration info
       def server_from_host(hostname=nil)
-        host = hostname || Agent.config[:host]
-
-        # if the host is not an IP address, turn it into one
-        NewRelic::Control::Server.new(host, Agent.config[:port],
-                                      convert_to_ip_address(host))
-      end
-
-      # Check to see if we need to look up the IP address
-      # If it's an IP address already, we pass it through.
-      # If it's nil, or localhost, we don't bother.
-      # Otherwise, use `resolve_ip_address` to find one
-      def convert_to_ip_address(host)
-        # here we leave it as a host name since the cert verification
-        # needs it in host form
-        return host if Agent.config[:ssl]
-        # We won't talk directly to the host, so no need to resolve if proxy configured
-        return host if Agent.config[:proxy_host]
-        return nil if host.nil? || host.downcase == "localhost"
-        ip = resolve_ip_address(host)
-
-        ::NewRelic::Agent.logger.debug "Resolved #{host} to #{ip}"
-        ip
-      end
-
-      # Look up the ip address of the host using the pure ruby lookup
-      # to prevent blocking.  If that fails, fall back to the regular
-      # IPSocket library.  Return nil if we can't find the host ip
-      # address and don't have a good default.
-      def resolve_ip_address(host)
-        Resolv.getaddress(host)
-      rescue => e
-        ::NewRelic::Agent.logger.warn("DNS Error caching IP address:", e)
-        begin
-          ::NewRelic::Agent.logger.debug("Trying native DNS lookup since Resolv failed")
-          IPSocket.getaddress(host)
-        rescue => e
-          ::NewRelic::Agent.logger.error("Could not look up server address: #{e}")
-          nil
-        end
+        NewRelic::Control::Server.new(hostname || Agent.config[:host], Agent.config[:port])
       end
     end
 

data/lib/new_relic/helper.rb

@@ -2,6 +2,7 @@
 # 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/language_support'
 
 module NewRelic
   # A singleton for shared generic helper methods

data/lib/new_relic/language_support.rb

@@ -111,6 +111,27 @@ module NewRelic::LanguageSupport
     RUBY_VERSION >= '1.9.0'
   end
 
+  def constantize(const_name)
+    const_name.to_s.sub(/\A::/,'').split('::').inject(Object) do |namespace, name|
+      begin
+        result = namespace.const_get(name)
+
+        # const_get looks up the inheritence chain, so if it's a class
+        # in the constant make sure we found the one in our namespace.
+        #
+        # Can't help if the constant isn't a class...
+        if result.is_a?(Module)
+          expected_name = "#{namespace}::#{name}".gsub(/^Object::/, "")
+          return unless expected_name == result.to_s
+        end
+
+        result
+      rescue NameError
+        nil
+      end
+    end
+  end
+
   def test_forkability
     child = Process.fork { exit! }
     # calling wait here doesn't seem like it should necessary, but it seems to

data/lib/new_relic/local_environment.rb

@@ -41,6 +41,7 @@ module NewRelic
         self.extend mod if mod.instance_of? Module
       end
 
+      @discovered_dispatcher = nil
       discover_dispatcher
     end
 

data/lib/new_relic/metric_data.rb

@@ -7,7 +7,7 @@ require 'new_relic/coerce'
 module NewRelic
   class MetricData
     # nil, or a NewRelic::MetricSpec object if we have no cached ID
-    attr_accessor :metric_spec
+    attr_reader :metric_spec
     # nil or a cached integer ID for the metric from the collector.
     attr_accessor :metric_id
     # the actual statistics object

data/lib/new_relic/noticed_error.rb

@@ -74,7 +74,7 @@ class NewRelic::NoticedError
   end
 
   def self.passes_message_whitelist(exception_class)
-    NewRelic::Agent.config.stripped_exceptions_whitelist.any? do |klass|
+    NewRelic::Agent.config[:'strip_exception_messages.whitelist'].any? do |klass|
       exception_class <= klass
     end
   end