newrelic_rpm 3.7.0.174.beta → 3.7.0.177

data/lib/new_relic/agent/new_relic_service.rb

@@ -32,7 +32,7 @@ module NewRelic
         @metric_id_cache = {}
         @last_metric_harvest_time = Time.now
 
-        @audit_logger = ::NewRelic::Agent::AuditLogger.new(Agent.config)
+        @audit_logger = ::NewRelic::Agent::AuditLogger.new
         Agent.config.register_callback(:'audit_log.enabled') do |enabled|
           @audit_logger.enabled = enabled
         end
@@ -178,25 +178,35 @@ module NewRelic
       def session(&block)
         raise ArgumentError, "#{self.class}#shared_connection must be passed a block" unless block_given?
 
-        http = create_http_connection
-
         # Immediately open a TCP connection to the server and leave it open for
         # multiple requests.
         begin
           t0 = Time.now
-          ::NewRelic::Agent.logger.debug("Opening TCP connection to #{http.address}:#{http.port}")
-          NewRelic::TimerLib.timeout(@request_timeout) { http.start }
-          @shared_tcp_connection = http
+          @in_session = true
+          establish_shared_connection
           block.call
         rescue Timeout::Error
           elapsed = Time.now - t0
-          ::NewRelic::Agent.logger.warn "Timed out opening connection to #{http.address}:#{http.port} after #{elapsed} seconds. If this problem persists, please see http://status.newrelic.com"
+          ::NewRelic::Agent.logger.warn "Timed out opening connection to collector after #{elapsed} seconds. If this problem persists, please see http://status.newrelic.com"
           raise
         ensure
+          @in_session = false
+          close_shared_connection
+        end
+      end
+
+      def establish_shared_connection
+        connection = create_http_connection
+        NewRelic::Agent.logger.debug("Opening shared TCP connection to #{connection.address}:#{connection.port}")
+        NewRelic::TimerLib.timeout(@request_timeout) { connection.start }
+        @shared_tcp_connection = connection
+      end
+
+      def close_shared_connection
+        if @shared_tcp_connection
+          ::NewRelic::Agent.logger.debug("Closing shared TCP connection to #{@shared_tcp_connection.address}:#{@shared_tcp_connection.port}")
+          @shared_tcp_connection.finish if @shared_tcp_connection.started?
           @shared_tcp_connection = nil
-          # Close the TCP socket
-          ::NewRelic::Agent.logger.debug("Closing TCP connection to #{http.address}:#{http.port}")
-          http.finish if http.started?
         end
       end
 
@@ -204,7 +214,9 @@ module NewRelic
       # We'll reuse the same handle for cases where we're using keep-alive, or
       # otherwise create a new one.
       def http_connection
-        @shared_tcp_connection || create_http_connection
+        (@shared_tcp_connection ||
+          (@in_session && establish_shared_connection) ||
+          create_http_connection)
       end
 
       # Return the Net::HTTP with proxy configuration given the NewRelic::Control::Server object.
@@ -329,14 +341,9 @@ module NewRelic
         response = nil
         http = http_connection
         http.read_timeout = nil
-        begin
-          NewRelic::TimerLib.timeout(@request_timeout) do
-            ::NewRelic::Agent.logger.debug "Sending request to #{opts[:collector]}#{opts[:uri]}"
-            response = http.request(request)
-          end
-        rescue Timeout::Error
-          ::NewRelic::Agent.logger.warn "Timed out trying to post data to New Relic (timeout = #{@request_timeout} seconds)"
-          raise
+        NewRelic::TimerLib.timeout(@request_timeout) do
+          ::NewRelic::Agent.logger.debug "Sending request to #{opts[:collector]}#{opts[:uri]}"
+          response = http.request(request)
         end
         case response
         when Net::HTTPSuccess
@@ -346,7 +353,6 @@ module NewRelic
         when Net::HTTPServiceUnavailable
           raise ServerConnectionException, "Service unavailable (#{response.code}): #{response.message}"
         when Net::HTTPGatewayTimeOut
-          ::NewRelic::Agent.logger.warn("Timed out getting response: #{response.message}")
           raise Timeout::Error, response.message
         when Net::HTTPRequestEntityTooLarge
           raise UnrecoverableServerException, '413 Request Entity Too Large'
@@ -356,8 +362,10 @@ module NewRelic
           raise ServerConnectionException, "Unexpected response from server (#{response.code}): #{response.message}"
         end
         response
-      rescue SystemCallError, SocketError => e
-        # These include Errno connection errors
+      rescue Timeout::Error, EOFError, SystemCallError, SocketError => e
+        # These include Errno connection errors, and all signify that the
+        # connection may be in a bad state, so drop it and re-create if needed.
+        close_shared_connection
         raise NewRelic::Agent::ServerConnectionException, "Recoverable error connecting to #{@collector}: #{e}"
       end
 

data/lib/new_relic/agent/obfuscator.rb

@@ -0,0 +1,48 @@
+# 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 'base64'
+
+module NewRelic
+  module Agent
+    class Obfuscator
+
+      attr_reader :key_bytes
+
+      EMPTY_KEY_BYTES = [0]
+
+      # RUM uses a shortened key, so just trim it up front
+      def initialize(key, length=nil)
+        if key.nil? || key.empty?
+          @key_bytes = EMPTY_KEY_BYTES
+        else
+          @key_bytes = key.bytes.to_a
+          @key_bytes = @key_bytes.first(length) if length
+        end
+      end
+
+      def obfuscate(text)
+        [ encode(text) ].pack('m').chomp.gsub(/\n/, '')
+      end
+
+      def deobfuscate(text)
+        encode(text.unpack('m').first )
+      end
+
+      def encode(text)
+        return text unless key_bytes
+
+        encoded = ""
+        encoded.force_encoding('binary') if encoded.respond_to?( :force_encoding )
+        index = 0
+        text.each_byte do |byte|
+          encoded.concat((byte ^ key_bytes[index % key_bytes.length]))
+          index+=1
+        end
+        encoded
+      end
+
+    end
+  end
+end

data/lib/new_relic/agent/request_sampler.rb

@@ -13,10 +13,7 @@ class NewRelic::Agent::RequestSampler
           MonitorMixin
 
   # The namespace and keys of config values
-  MAX_SAMPLES_KEY            = :'analytics_events.max_samples_stored'
   ENABLED_KEY                = :'analytics_events.enabled'
-  ENABLED_TXN_KEY            = :'analytics_events.transactions.enabled'
-  INCLUDE_CUSTOM_PARAMS_KEY  = :'capture_attributes.transaction_events'
 
   # The type field of the sample
   SAMPLE_TYPE              = 'Transaction'
@@ -31,7 +28,7 @@ class NewRelic::Agent::RequestSampler
     super()
 
     @enabled       = false
-    @samples       = ::NewRelic::Agent::SampledBuffer.new(NewRelic::Agent.config[MAX_SAMPLES_KEY])
+    @samples       = ::NewRelic::Agent::SampledBuffer.new(NewRelic::Agent.config[:'analytics_events.max_samples_stored'])
     @notified_full = false
 
     event_listener.subscribe( :transaction_finished, &method(:on_transaction_finished) )
@@ -67,7 +64,7 @@ class NewRelic::Agent::RequestSampler
 
   # Clear any existing samples, reset the last sample time, and return the
   # previous set of samples. (Synchronized)
-  def harvest
+  def harvest!
     old_samples, sample_count, request_count = reset!
     record_sampling_rate(request_count, sample_count) if @enabled
     old_samples
@@ -99,7 +96,7 @@ class NewRelic::Agent::RequestSampler
   end
 
   def register_config_callbacks
-    NewRelic::Agent.config.register_callback(MAX_SAMPLES_KEY) do |max_samples|
+    NewRelic::Agent.config.register_callback(:'analytics_events.max_samples_stored') do |max_samples|
       NewRelic::Agent.logger.debug "RequestSampler max_samples set to #{max_samples}"
       self.synchronize { @samples.capacity = max_samples }
       self.reset!
@@ -107,12 +104,7 @@ class NewRelic::Agent::RequestSampler
 
     NewRelic::Agent.config.register_callback(ENABLED_KEY) do |enabled|
       NewRelic::Agent.logger.info "%sabling the Request Sampler." % [ enabled ? 'En' : 'Dis' ]
-      @enabled = enabled && NewRelic::Agent.config[ENABLED_TXN_KEY]
-    end
-
-    NewRelic::Agent.config.register_callback(ENABLED_TXN_KEY) do |enabled|
-      NewRelic::Agent.logger.info "%sabling the Request Sampler." % [ enabled ? 'En' : 'Dis' ]
-      @enabled = enabled && NewRelic::Agent.config[ENABLED_KEY]
+      @enabled = enabled
     end
   end
 
@@ -128,7 +120,7 @@ class NewRelic::Agent::RequestSampler
     # The order in which these are merged is important.  We want to ensure that
     # custom parameters can't override required fields (e.g. type)
     sample = {}
-    if ::NewRelic::Agent.config[INCLUDE_CUSTOM_PARAMS_KEY]
+    if ::NewRelic::Agent.config[:'capture_attributes.transaction_events']
       sample.merge!(event_params(payload[:custom_params] || {}))
     end
     sample.merge!(payload[:overview_metrics] || {})

data/lib/new_relic/agent/shim_agent.rb

@@ -26,6 +26,7 @@ module NewRelic
       def push_trace_execution_flag *args; end
       def pop_trace_execution_flag *args; end
       def browser_timing_header; "" end
+      def browser_timing_config; "" end
       def browser_timing_footer; "" end
     end
   end

data/lib/new_relic/agent/sql_sampler.rb

@@ -96,7 +96,6 @@ module NewRelic
                 sql_item, transaction_sql_data.path, transaction_sql_data.uri)
           end
         end
-
       end
 
       def notice_sql(sql, metric_name, config, duration, &explainer)
@@ -104,7 +103,7 @@ module NewRelic
         if NewRelic::Agent.is_sql_recorded?
           if duration > Agent.config[:'slow_sql.explain_threshold']
             backtrace = caller.join("\n")
-            transaction_data.sql_data << SlowSql.new(TransactionSampler.truncate_message(sql),
+            transaction_data.sql_data << SlowSql.new(Database.capture_query(sql),
                                                      metric_name, config,
                                                      duration, backtrace, &explainer)
           end
@@ -113,12 +112,18 @@ module NewRelic
 
       def merge!(sql_traces)
         @samples_lock.synchronize do
-#FIXME we need to merge the sql_traces array back into the @sql_traces hash
-#          @sql_traces.merge! sql_traces
+          sql_traces.each do |trace|
+            existing_trace = @sql_traces[trace.sql]
+            if existing_trace
+              existing_trace.aggregate_trace(trace)
+            else
+              @sql_traces[trace.sql] = trace
+            end
+          end
         end
       end
 
-      def harvest
+      def harvest!
         return [] if !Agent.config[:'slow_sql.enabled']
         result = []
         @samples_lock.synchronize do
@@ -203,6 +208,7 @@ module NewRelic
       attr_reader :sql
       attr_reader :database_metric_name
       attr_reader :params
+      attr_reader :slow_sql
 
       def initialize(normalized_query, slow_sql, path, uri)
         super()
@@ -230,6 +236,10 @@ module NewRelic
         record_data_point(float(slow_sql.duration))
       end
 
+      def aggregate_trace(trace)
+        aggregate(trace.slow_sql, trace.path, trace.url)
+      end
+
       def prepare_to_send
         params[:explain_plan] = @slow_sql.explain if need_to_explain?
         @sql = @slow_sql.obfuscate if need_to_obfuscate?

data/lib/new_relic/agent/stats_engine/metric_stats.rb

@@ -116,7 +116,7 @@ module NewRelic
           end
         end
 
-        def reset_stats
+        def reset!
           with_stats_lock do
             old = @stats_hash
             @stats_hash = StatsHash.new
@@ -124,6 +124,11 @@ module NewRelic
           end
         end
 
+        # Renamed to reset!, here for backwards compatibility with 3rd-party
+        # gems (though this really isn't part of the public API).
+        # @deprecated
+        def reset_stats; reset!; end
+
         # merge data from previous harvests into this stats engine
         def merge!(other_stats_hash)
           with_stats_lock do
@@ -131,9 +136,9 @@ module NewRelic
           end
         end
 
-        def harvest
+        def harvest!
           now = Time.now
-          snapshot = reset_stats
+          snapshot = reset!
           snapshot = apply_rules_to_metric_data(@metric_rules, snapshot)
           snapshot.harvested_at = now
           snapshot
@@ -165,7 +170,7 @@ module NewRelic
 
         # For use by test code only.
         def clear_stats
-          reset_stats
+          reset!
           NewRelic::Agent::BusyCalculator.reset
         end
 

data/lib/new_relic/agent/transaction.rb

@@ -276,7 +276,6 @@ module NewRelic
 
       # Do not call this.  Invoke the class method instead.
       def notice_error(e, options={}) # :nodoc:
-        params = custom_parameters
         options[:referer] = referer if referer
         options[:request_params] = filtered_params if filtered_params
         options[:uri] = uri if uri

data/lib/new_relic/agent/transaction_sampler.rb

@@ -92,6 +92,14 @@ module NewRelic
         builder.trace_exit(scope, time.to_f)
       end
 
+      def custom_parameters_from_transaction(txn)
+        if Agent.config[:'capture_attributes.traces']
+          txn.custom_parameters
+        else
+          {}
+        end
+      end
+
       # This is called when we are done with the transaction.  We've
       # unwound the stack to the top level. It also clears the
       # transaction sample builder so that it won't continue to have
@@ -105,7 +113,7 @@ module NewRelic
 
         return unless last_builder
 
-        last_builder.finish_trace(time.to_f, txn.custom_parameters)
+        last_builder.finish_trace(time.to_f, custom_parameters_from_transaction(txn))
         clear_builder
         return if last_builder.ignored?
 
@@ -156,9 +164,9 @@ module NewRelic
         segment = builder.current_segment
         if segment
           if key != :sql
-            segment[key] = self.class.truncate_message(append_new_message(segment[key],
-                                                                          message))
+            segment[key] = self.class.truncate_message(message)
           else
+            # message is expected to have been pre-truncated by notice_sql
             segment[key] = message
           end
           append_backtrace(segment, duration)
@@ -178,16 +186,6 @@ module NewRelic
         end
       end
 
-      # Allows the addition of multiple pieces of metadata to one
-      # segment - i.e. traced method calls multiple sql queries
-      def append_new_message(old_message, message)
-        if old_message
-          old_message + ";\n" + message
-        else
-          message
-        end
-      end
-
       # Appends a backtrace to a segment if that segment took longer
       # than the specified duration
       def append_backtrace(segment, duration)
@@ -208,7 +206,7 @@ module NewRelic
       end
 
       def build_database_statement(sql, config, explainer)
-        statement = Database::Statement.new(self.class.truncate_message(sql))
+        statement = Database::Statement.new(Database.capture_query(sql))
         if config
           statement.adapter = config[:adapter]
           statement.config = config
@@ -235,13 +233,27 @@ module NewRelic
       end
 
       # Gather transaction traces that we'd like to transmit to the server.
-      def harvest
+      def harvest!
         return [] unless enabled?
 
-        @samples_lock.synchronize do
+        samples = @samples_lock.synchronize do
           @last_sample = nil
           harvest_from_sample_buffers
         end
+        prepare_samples(samples)
+      end
+
+      def prepare_samples(samples)
+        samples.select do |sample|
+          begin
+            sample.prepare_to_send!
+          rescue => e
+            NewRelic::Agent.logger.error("Failed to prepare transaction trace. Error: ", e)
+            false
+          else
+            true
+          end
+        end
       end
 
       def merge!(previous)

data/lib/new_relic/agent/transaction_state.rb

@@ -63,6 +63,15 @@ module NewRelic
       # Request data
       attr_accessor :request, :request_token, :request_guid, :request_ignore_enduser
 
+      def request_guid_to_include
+        return "" unless include_guid?
+        request_guid
+      end
+
+      def include_guid?
+        request_token && timings.app_time_in_seconds > transaction.apdex_t
+      end
+
       # Current transaction stack and sample building
       attr_accessor :transaction, :transaction_sample_builder
       attr_writer   :current_transaction_stack

data/lib/new_relic/agent/transaction_timings.rb

@@ -15,7 +15,11 @@ module NewRelic
       end
 
       attr_reader :transaction_name,
-        :start_time_in_seconds, :queue_time_in_seconds
+                  :start_time_in_seconds, :queue_time_in_seconds
+
+      def transaction_name_or_unknown
+        transaction_name || ::NewRelic::Agent::UNKNOWN_METRIC
+      end
 
       def start_time_as_time
         Time.at(@start_time_in_seconds)

data/lib/new_relic/agent/worker_loop.rb

@@ -85,19 +85,9 @@ module NewRelic
         else
           begin
             @task.call
-          rescue ServerError => e
-            ::NewRelic::Agent.logger.debug "Server Error:", e
           rescue NewRelic::Agent::ForceRestartException, NewRelic::Agent::ForceDisconnectException
             # blow out the loop
             raise
-          rescue RuntimeError => e
-            # This is probably a server error which has been logged in the server along
-            # with your account name.
-            ::NewRelic::Agent.logger.error "Error running task in worker loop, likely a server error:", e
-          rescue Timeout::Error, NewRelic::Agent::ServerConnectionException
-            # Want to ignore these because they are handled already
-          rescue SystemExit, NoMemoryError, SignalException
-            raise
           rescue => e
             # Don't blow out the stack for anything that hasn't already propagated
             ::NewRelic::Agent.logger.error "Error running task in Agent Worker Loop:", e