wd_newrelic_rpm 3.5.5 → 3.5.6

data/lib/new_relic/agent/agent_logger.rb

@@ -32,6 +32,10 @@ module NewRelic
         @log.debug(format_messages(msgs))
       end
 
+      def is_startup_logger?
+        false
+      end
+
       # Allows for passing exceptions in explicitly, which format with backtrace
       def format_messages(msgs)
         msgs.map do |msg|
@@ -120,12 +124,16 @@ module NewRelic
       end
     end
 
-    # BBase class for startup logging and testing in multiverse
+    # Base class for startup logging and testing in multiverse
     class MemoryLogger
       def initialize
         @messages = []
       end
 
+      def is_startup_logger?
+        true
+      end
+
       attr_accessor :messages, :level
 
       def fatal(*msgs)

data/lib/new_relic/agent/busy_calculator.rb

@@ -31,10 +31,15 @@ module NewRelic
       # 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")}")

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

@@ -30,7 +30,7 @@ module NewRelic
             when 4
               :rails4
             else
-              Agent.logger.error "Detected unsupported Rails version #{Rails::VERSION::STRING}"
+              ::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
@@ -55,8 +55,8 @@ module NewRelic
         :api_host               => 'rpm.newrelic.com',
         :port                   => Proc.new { self[:ssl] ? 443 : 80 },
         :api_port               => Proc.new { self[:port] },
-        :ssl                    => false,
-        :verify_certificate     => false,
+        :ssl                    => true,
+        :verify_certificate     => true,
         :sync_startup           => false,
         :send_data_on_exit      => true,
         :post_size_limit        => 2 * 1024 * 1024, # 2 megs

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

@@ -20,10 +20,14 @@ module NewRelic
         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)
@@ -86,6 +90,14 @@ module NewRelic
           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

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

@@ -4,6 +4,7 @@ module NewRelic
       MASK_DEFAULTS = {
         :'thread_profiler' =>         Proc.new { !NewRelic::Agent::ThreadProfiler.is_supported? },
         :'thread_profiler.enabled' => Proc.new { !NewRelic::Agent::ThreadProfiler.is_supported? },
+        :verify_certificate =>  Proc.new{ true }
       }
     end
   end

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

@@ -25,7 +25,11 @@ module NewRelic
             license_key = ''
 
             erb = ERB.new(file).result(binding)
-            config = merge!(YAML.load(erb)[env] || {})
+            confighash = YAML.load(erb)
+            ::NewRelic::Agent.logger.error("Config (#{path}) doesn't include a '#{env}' environment!") unless
+              confighash.key?(env)
+
+            config = merge!(confighash[env] || {})
           rescue ScriptError, StandardError => e
             ::NewRelic::Agent.logger.error("Unable to read configuration file #{path}: #{e}")
           end

data/lib/new_relic/agent/cross_process_monitoring.rb

@@ -1,43 +1,187 @@
+require 'new_relic/rack/agent_hooks'
+require 'new_relic/agent/thread'
+
 module NewRelic
   module Agent
-    module CrossProcessMonitoring
+    class CrossProcessMonitor
+
+      def initialize(events = nil)
+        # When we're starting up for real in the agent, we get passed the events
+        # Other spots can pull from the agent, during startup the agent doesn't exist yet!
+        events ||= Agent.instance.events
+        @trusted_ids = []
+
+        events.subscribe(:finished_configuring) do
+          finish_setup(Agent.config)
+          register_event_listeners
+        end
+      end
+
+      def finish_setup(config)
+        @cross_process_id = config[:cross_process_id]
+        @encoding_key = config[:encoding_key]
+        @encoding_bytes = get_bytes(@encoding_key) unless @encoding_key.nil?
+        @trusted_ids = config[:trusted_account_ids] || []
+      end
+
+      # Expected sequence of events:
+      #   :before_call will save our cross process request id to the thread
+      #   :start_transaction will get called when a transaction starts up
+      #   :after_call will write our response headers/metrics and clean up the thread
+      def register_event_listeners
+        NewRelic::Agent.logger.debug("Wiring up Cross Process monitoring to events after finished configuring")
+
+        events = Agent.instance.events
+        events.subscribe(:before_call) do |env|
+          save_client_cross_process_id(env)
+        end
+
+        events.subscribe(:start_transaction) do |name|
+          set_transaction_custom_parameters
+        end
+
+        events.subscribe(:after_call) do |env, (status_code, headers, body)|
+          insert_response_header(env, headers)
+        end
+
+        events.subscribe(:notice_error) do |_, options|
+          set_error_custom_parameters(options)
+        end
+      end
+
+      # Because we aren't in the right spot when our transaction actually
+      # starts, hold client_cross_process_id we get thread local until then.
+      THREAD_ID_KEY = :newrelic_client_cross_process_id
+
+      def save_client_cross_process_id(request_headers)
+        if should_process_request(request_headers)
+          NewRelic::Agent::AgentThread.current[THREAD_ID_KEY] = decoded_id(request_headers)
+        end
+      end
 
-      module_function
+      def clear_client_cross_process_id
+        NewRelic::Agent::AgentThread.current[THREAD_ID_KEY] = nil
+      end
 
-      def insert_response_header(request, response)
-        if Agent.config[:'cross_process.enabled'] &&
-            NewRelic::Agent.instance.cross_process_id && (id = id_from_request(request))
+      def client_cross_process_id
+        NewRelic::Agent::AgentThread.current[THREAD_ID_KEY]
+      end
 
-          content_length = -1
+      def insert_response_header(request_headers, response_headers)
+        unless client_cross_process_id.nil?
           timings = NewRelic::Agent::BrowserMonitoring.timings
+          content_length = content_length_from_request(request_headers)
+
+          set_response_headers(response_headers, timings, content_length)
+          set_metrics(client_cross_process_id, timings)
+
+          clear_client_cross_process_id
+        end
+      end
+
+      def should_process_request(request_headers)
+        return Agent.config[:'cross_process.enabled'] &&
+            @cross_process_id &&
+            trusts?(request_headers)
+      end
+
+      # Expects an ID of format "12#345", and will only accept that!
+      def trusts?(request)
+        id = decoded_id(request)
+        split_id = id.match(/(\d+)#\d+/)
+        return false if split_id.nil?
 
-          # FIXME the transaction name might not be properly encoded.  use a json generator
-          payload = %[["#{NewRelic::Agent.instance.cross_process_id}","#{timings.transaction_name}",#{timings.queue_time_in_millis},#{timings.app_time_in_millis},#{content_length}] ]
-          payload = obfuscate_with_key(payload, NewRelic::Agent.instance.cross_process_encoding_bytes)
+        @trusted_ids.include?(split_id.captures.first.to_i)
+      end
+
+      def set_response_headers(response_headers, timings, content_length)
+        response_headers['X-NewRelic-App-Data'] = build_payload(timings, content_length)
+      end
+
+      def build_payload(timings, content_length)
+
+        # FIXME The transaction name might not be properly encoded.  use a json generator
+        # For now we just handle quote characters by dropping them
+        transaction_name = timings.transaction_name.gsub(/["']/, "")
+
+        payload = %[["#{@cross_process_id}","#{transaction_name}",#{timings.queue_time_in_seconds},#{timings.app_time_in_seconds},#{content_length}] ]
+        payload = obfuscate_with_key(payload)
+      end
+
+      def set_transaction_custom_parameters
+        # We expect to get the before call to set the id (if we have it) before
+        # this, and then write our custom parameter when the transaction starts
+        NewRelic::Agent.add_custom_parameters(:client_cross_process_id => client_cross_process_id) unless client_cross_process_id.nil?
+      end
+
+      def set_error_custom_parameters(options)
+        options[:client_cross_process_id] = client_cross_process_id unless client_cross_process_id.nil?
+      end
+
+      def set_metrics(id, timings)
+        metric = NewRelic::Agent.instance.stats_engine.get_stats_no_scope("ClientApplication/#{id}/all")
+        metric.record_data_point(timings.app_time_in_seconds)
+      end
+
+      def obfuscate_with_key(text)
+        Base64.encode64(encode_with_key(text)).chomp
+      end
 
-          response['X-NewRelic-App-Data'] = payload
-          #FIXME generate ClientApplication metric.  id must be decoded first
-          # String metricName = MessageFormat.format("ClientApplication/{0}/all", id);
+      def decode_with_key(text)
+        encode_with_key(Base64.decode64(text))
+      end
+
+      NEWRELIC_ID_HEADER_KEYS = %w{X-NewRelic-ID HTTP_X_NEWRELIC_ID X_NEWRELIC_ID}
+      CONTENT_LENGTH_HEADER_KEYS = %w{Content-Length HTTP_CONTENT_LENGTH CONTENT_LENGTH}
+
+      def decoded_id(request)
+        encoded_id = from_headers(request, NEWRELIC_ID_HEADER_KEYS)
+        return "" if encoded_id.nil?
+
+        decode_with_key(encoded_id)
+      end
+
+      def content_length_from_request(request)
+        from_headers(request, CONTENT_LENGTH_HEADER_KEYS) || -1
+      end
+
+
+
+      private
+
+      # Ruby 1.8.6 doesn't support the bytes method on strings.
+      def get_bytes(value)
+        return [] if value.nil?
+
+        bytes = []
+        value.each_byte do |b|
+          bytes << b
         end
+        bytes
       end
 
-      def obfuscate_with_key(text, key_bytes)
-        obfuscated = ""
+      def encode_with_key(text)
+        key_bytes =  @encoding_bytes
+
+        encoded = ""
         index = 0
         text.each_byte{|byte|
-          obfuscated.concat((byte ^ key_bytes[index % key_bytes.length].to_i))
+          encoded.concat((byte ^ key_bytes[index % key_bytes.length].to_i))
           index+=1
         }
-
-        [obfuscated].pack("m0").gsub("\n", '')
+        encoded
       end
 
-      def id_from_request(request)
-        %w{X-NewRelic-ID HTTP_X_NEWRELIC_ID X_NEWRELIC_ID}.each do |header|
-          return request.env[header] if request.env.has_key?(header)
+      def from_headers(request, try_keys)
+        # For lookups, upcase all our keys on both sides just to be safe
+        upcased_keys = try_keys.map{|k| k.upcase}
+        upcased_keys.each do |header|
+          found_key = request.keys.find { |k| k.upcase == header }
+          return request[found_key] unless found_key.nil?
         end
         nil
       end
+
     end
   end
 end

data/lib/new_relic/agent/error_collector.rb

@@ -21,6 +21,8 @@ module NewRelic
       # Returns a new error collector
       def initialize
         @errors = []
+        @seen_error_ids = []
+
         # lookup of exception class names to ignore.  Hash for fast access
         @ignore = {}
         @capture_source = Agent.config[:'error_collector.capture_source']
@@ -92,7 +94,11 @@ module NewRelic
         end
 
         # Increments a statistic that tracks total error rate
-        def increment_error_count!
+        # Be sure not to double-count same exception. This clears per harvest.
+        def increment_error_count!(exception)
+          return if @seen_error_ids.include?(exception.object_id)
+          @seen_error_ids << exception.object_id
+
           NewRelic::Agent.get_stats("Errors/all").increment_count
         end
 
@@ -102,7 +108,7 @@ module NewRelic
         def should_exit_notice_error?(exception)
           if enabled?
             if !error_is_ignored?(exception)
-              increment_error_count!
+              increment_error_count!(exception)
               return exception.nil? # exit early if the exception is nil
             end
           end
@@ -211,6 +217,7 @@ module NewRelic
 
       include NoticeError
 
+
       # Notice the error with the given available options:
       #
       # * <tt>:uri</tt> => The request path, minus any request params or query string.
@@ -223,6 +230,7 @@ module NewRelic
       # If exception is nil, the error count is bumped and no traced error is recorded
       def notice_error(exception, options={})
         return if should_exit_notice_error?(exception)
+        NewRelic::Agent.instance.events.notify(:notice_error, exception, options)
         action_path     = fetch_from_options(options, :metric, (NewRelic::Agent.instance.stats_engine.scope_name || ''))
         exception_options = error_params_from_options(options).merge(exception_info(exception))
         add_to_error_queue(NewRelic::NoticedError.new(action_path, exception_options, exception))
@@ -238,6 +246,9 @@ module NewRelic
           errors = @errors
           @errors = []
 
+          # Only expect to re-see errors on same request, so clear on harvest
+          @seen_error_ids = []
+
           if unsent_errors && !unsent_errors.empty?
             errors = unsent_errors + errors
           end

data/lib/new_relic/agent/event_listener.rb

@@ -0,0 +1,39 @@
+module NewRelic::Agent
+  # Basic mechanism for the agent instance to provide agent-wide eventing.
+  # It is intended to keep different pieces of the app decoupled from each other.
+  #
+  # While an EventListener could be used elsewhere, it's strongly expected
+  # your eventing needs should be met by the agent's instance.
+  class EventListener
+
+    attr_accessor :runaway_threshold
+
+    def initialize
+      @events = {}
+      @runaway_threshold = 100
+    end
+
+    def subscribe(event, &handler)
+      @events[event] ||= []
+      @events[event] << handler
+      check_for_runaway_subscriptions(event)
+    end
+
+    def check_for_runaway_subscriptions(event)
+      count = @events[event].size
+      NewRelic::Agent.logger.debug("Run-away event subscription on #{event}? Subscribed #{count}") if count > @runaway_threshold
+    end
+
+    def notify(event, *args)
+      return unless @events.has_key?(event)
+
+      @events[event].each do |handler|
+        begin
+          handler.call(*args)
+        rescue => err
+          NewRelic::Agent.logger.debug("Failure during notify for #{@event}", err)
+        end
+      end
+    end
+  end
+end

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

@@ -4,37 +4,47 @@ module NewRelic
       class BrowserMonitoringTimings
 
         def initialize(queue_time_in_seconds, 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
+            @start_time_in_seconds = transaction.start_time.to_i
           end
 
-          @queue_time_in_seconds = queue_time_in_seconds
+          @queue_time_in_seconds = clamp_to_positive(queue_time_in_seconds)
         end
 
-        attr_reader :transaction_name
+        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)
+          convert_to_milliseconds(queue_time_in_seconds)
         end
 
         def app_time_in_millis
-          convert_to_milliseconds(Time.now - @start_time_in_seconds)
+          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)
-          value = (value.to_f * 1000.0).round
-          return 0.0 if value < 0
+        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