newrelic_rpm 3.7.0.177 → 3.7.1.180

data/lib/new_relic/agent/datastores/mongo/obfuscator.rb

@@ -0,0 +1,39 @@
+# 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 Datastores
+      module Mongo
+        module Obfuscator
+
+          WHITELIST = [:operation].freeze
+
+          def self.obfuscate_statement(source, whitelist=WHITELIST)
+            obfuscated = {}
+            source.each do |key, value|
+              if whitelist.include?(key)
+                obfuscated[key] = value
+              else
+                obfuscated[key] = obfuscate_value(value, whitelist)
+              end
+            end
+
+            obfuscated
+          end
+
+          def self.obfuscate_value(value, whitelist)
+            if value.is_a?(Hash)
+              obfuscate_statement(value, whitelist)
+            elsif value.is_a?(Array)
+              value.map {|v| obfuscate_value(v, whitelist)}
+            else
+              '?'
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/datastores/mongo/statement_formatter.rb

@@ -0,0 +1,52 @@
+# 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/datastores/mongo/obfuscator'
+
+module NewRelic
+  module Agent
+    module Datastores
+      module Mongo
+        module StatementFormatter
+
+          PLAINTEXT_KEYS = [
+            :database,
+            :collection,
+            :operation,
+            :fields,
+            :skip,
+            :limit,
+            :order
+          ]
+
+          OBFUSCATE_KEYS = [
+            :selector
+          ]
+
+          def self.format(statement)
+            return nil unless NewRelic::Agent.config[:'mongo.capture_queries']
+
+            result = {}
+            PLAINTEXT_KEYS.each do |key|
+              result[key] = statement[key] if statement.key?(key)
+            end
+
+            OBFUSCATE_KEYS.each do |key|
+              if statement.key?(key)
+                obfuscated = obfuscate(statement[key])
+                result[key] = obfuscated if obfuscated
+              end
+            end
+            result
+          end
+
+          def self.obfuscate(statement)
+            statement = Obfuscator.obfuscate_statement(statement) if NewRelic::Agent.config[:'mongo.obfuscate_queries']
+            statement
+          end
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/harvester.rb

@@ -0,0 +1,55 @@
+# 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 Harvester
+      attr_accessor :starting_pid
+
+      # Inject target for after_fork call to avoid spawning thread in tests
+      def initialize(events, after_forker=NewRelic::Agent)
+        @starting_pid = Process.pid
+        @after_forker = after_forker
+        @lock = Mutex.new
+
+        if events
+          events.subscribe(:start_transaction, &method(:on_transaction))
+        end
+      end
+
+      def on_transaction(*_)
+        return unless restart_in_children_enabled? && needs_restart?
+
+        needs_thread_start = false
+        @lock.synchronize do
+          needs_thread_start = needs_restart?
+          mark_started
+        end
+
+        if needs_thread_start
+          restart_harvest_thread
+        end
+      end
+
+      def mark_started(pid = Process.pid)
+        @starting_pid = pid
+      end
+
+      def needs_restart?(pid = Process.pid)
+        @starting_pid != pid
+      end
+
+      def restart_in_children_enabled?
+        NewRelic::Agent.config[:restart_thread_in_children]
+      end
+
+      def restart_harvest_thread
+        # Daemonize reports thread as still alive when it isn't... whack!
+        NewRelic::Agent.instance.instance_variable_set(:@worker_thread, nil)
+        @after_forker.after_fork(:force_reconnect => true)
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,139 @@
+# 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.
+
+DependencyDetection.defer do
+  named :mongo
+
+  depends_on do
+    if defined?(::Mongo) && defined?(::Mongo::Logging)
+      true
+    else
+      if defined?(::Mongo)
+        NewRelic::Agent.logger.info 'Mongo instrumentation requires Mongo::Logging'
+      end
+
+      false
+    end
+  end
+
+  depends_on do
+    require 'new_relic/agent/datastores/mongo'
+    NewRelic::Agent::Datastores::Mongo.is_supported_version?
+  end
+
+  executes do
+    NewRelic::Agent.logger.info 'Installing Mongo instrumentation'
+    install_mongo_instrumentation
+  end
+
+  def install_mongo_instrumentation
+    instrument_mongo_logging
+    instrument_save
+    instrument_ensure_index
+  end
+
+  def instrument_mongo_logging
+    ::Mongo::Logging.class_eval do
+      include NewRelic::Agent::MethodTracer
+      require 'new_relic/agent/datastores/mongo/metric_generator'
+      require 'new_relic/agent/datastores/mongo/statement_formatter'
+
+      def instrument_with_new_relic_trace(name, payload = {}, &block)
+        metrics = NewRelic::Agent::Datastores::Mongo::MetricGenerator.generate_metrics_for(name, payload)
+
+        trace_execution_scoped(metrics) do
+          t0 = Time.now
+          result = instrument_without_new_relic_trace(name, payload, &block)
+
+          payload[:operation] = name
+          statement = NewRelic::Agent::Datastores::Mongo::StatementFormatter.format(payload)
+          if statement
+            NewRelic::Agent.instance.transaction_sampler.notice_nosql_statement(statement, (Time.now - t0).to_f)
+          end
+
+          result
+        end
+      end
+
+      ::Mongo::Collection.class_eval { include Mongo::Logging; }
+      ::Mongo::Connection.class_eval { include Mongo::Logging; }
+      ::Mongo::Cursor.class_eval { include Mongo::Logging; }
+
+      alias_method :instrument_without_new_relic_trace, :instrument
+      alias_method :instrument, :instrument_with_new_relic_trace
+    end
+  end
+
+  def instrument_save
+    ::Mongo::Collection.class_eval do
+      include NewRelic::Agent::MethodTracer
+      require 'new_relic/agent/datastores/mongo/metric_generator'
+      require 'new_relic/agent/datastores/mongo/statement_formatter'
+
+      def save_with_new_relic_trace(doc, opts = {}, &block)
+        metrics = NewRelic::Agent::Datastores::Mongo::MetricGenerator.generate_metrics_for(:save, { :collection => self.name })
+
+        trace_execution_scoped(metrics) do
+          t0 = Time.now
+
+          transaction_state = NewRelic::Agent::TransactionState.get
+          transaction_state.push_traced(false)
+
+          begin
+            result = save_without_new_relic_trace(doc, opts, &block)
+          ensure
+            transaction_state.pop_traced
+          end
+
+          doc[:operation] = :save
+          statement = NewRelic::Agent::Datastores::Mongo::StatementFormatter.format(doc)
+          if statement
+            NewRelic::Agent.instance.transaction_sampler.notice_nosql_statement(statement, (Time.now - t0).to_f)
+          end
+
+          result
+        end
+      end
+
+      alias_method :save_without_new_relic_trace, :save
+      alias_method :save, :save_with_new_relic_trace
+    end
+  end
+
+  def instrument_ensure_index
+    ::Mongo::Collection.class_eval do
+      include NewRelic::Agent::MethodTracer
+      require 'new_relic/agent/datastores/mongo/metric_generator'
+      require 'new_relic/agent/datastores/mongo/statement_formatter'
+
+      def ensure_index_with_new_relic_trace(spec, opts = {}, &block)
+        metrics = NewRelic::Agent::Datastores::Mongo::MetricGenerator.generate_metrics_for(:ensureIndex, { :collection => self.name })
+
+        trace_execution_scoped(metrics) do
+          t0 = Time.now
+
+          transaction_state = NewRelic::Agent::TransactionState.get
+          transaction_state.push_traced(false)
+
+          begin
+            result = save_without_new_relic_trace(spec, opts, &block)
+          ensure
+            transaction_state.pop_traced
+          end
+
+          spec[:operation] = :ensureIndex
+          statement = NewRelic::Agent::Datastores::Mongo::StatementFormatter.format(spec)
+          if statement
+            NewRelic::Agent.instance.transaction_sampler.notice_nosql_statement(statement, (Time.now - t0).to_f)
+          end
+
+          result
+        end
+      end
+
+      alias_method :ensure_index_without_new_relic_trace, :ensure_index
+      alias_method :ensure_index, :ensure_index_with_new_relic_trace
+    end
+  end
+end

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

@@ -17,20 +17,15 @@ DependencyDetection.defer do
 
   executes do
     class Net::HTTP
-      # Instrument outgoing HTTP requests
-      #
-      # If request is called when not the connection isn't started, request
-      # will call back into itself (via a start block).
-      #
-      # Don't tracing until the inner call then to avoid double-counting.
       def request_with_newrelic_trace(request, *args, &block)
-        if started?
-          wrapped_request = NewRelic::Agent::HTTPClients::NetHTTPRequest.new(self, request)
-          NewRelic::Agent::CrossAppTracing.trace_http_request( wrapped_request ) do
+        wrapped_request = NewRelic::Agent::HTTPClients::NetHTTPRequest.new(self, request)
+
+        NewRelic::Agent::CrossAppTracing.trace_http_request( wrapped_request ) do
+          # RUBY-1244 Disable further tracing in request to avoid double
+          # counting if connection wasn't started (which calls request again).
+          NewRelic::Agent.disable_all_tracing do
             request_without_newrelic_trace( request, *args, &block )
           end
-        else
-          request_without_newrelic_trace( request, *args, &block )
         end
       end
 

data/lib/new_relic/agent/supported_versions.rb

@@ -32,12 +32,9 @@ module NewRelic
       {
         :type        => :ruby,
         :name        => "Rubinius",
-        :experimental=> ["~> 2.1.1"],
+        :supported   => ["~> 2.2.1"],
         :url         => "http://rubini.us",
-        :feed        => "http://rubini.us/feed/atom.xml",
-        :notes       => [
-          "Support for Rubinius 2.x is considered experimental.",
-          "Consider using the latest for best results, and watch http://docs.newrelic.com/docs/ruby/rubinius for updates."]
+        :feed        => "http://rubini.us/feed/atom.xml"
       },
 
       # App servers
@@ -141,6 +138,13 @@ module NewRelic
         :url         => "https://rubygems.org/gems/sequel",
         :feed        => "https://rubygems.org/gems/sequel/versions.atom"
       },
+      :mongo =>
+      {
+        :type        => :database,
+        :supported   => ["~>1.8.0", "~>1.9.0"],
+        :url         => "https://rubygems.org/gems/mongo",
+        :feed        => "https://rubygems.org/gems/mongo/versions.atom"
+      },
 
       # Background Jobs
       :resque =>

data/lib/new_relic/agent/transaction_sampler.rb

@@ -226,6 +226,10 @@ module NewRelic
         notice_extra_data(key, duration, :key)
       end
 
+      def notice_nosql_statement(statement, duration)
+        notice_extra_data(statement, duration, :statement)
+      end
+
       # Set parameters on the current segment.
       def add_segment_parameters( params )
         return unless builder

data/lib/new_relic/version.rb

@@ -12,7 +12,7 @@ module NewRelic
 
     MAJOR = 3
     MINOR = 7
-    TINY  = 0
+    TINY  = 1
 
     begin
       require File.join(File.dirname(__FILE__), 'build')

data/lib/tasks/versions.rake

@@ -33,7 +33,7 @@ namespace :newrelic do
     def write_versions(title, type, erb, suppress_versions = false)
       anchor = title.downcase.gsub(" ", "_")
       versions = versions_for_type(type)
-      puts erb.result(binding)
+      puts erb.result(binding).gsub(/^ *$/, '')
     end
 
     VersionStruct = Struct.new(:name, :supported, :deprecated, :experimental, :notes)

data/test/agent_helper.rb

@@ -205,6 +205,10 @@ unless defined?( assert_false )
   end
 end
 
+unless defined? ( refute )
+  alias refute assert_false
+end
+
 # Mock up a transaction for testing purposes, optionally specifying a name and
 # transaction type. The given block will be executed within the context of the
 # dummy transaction.

data/test/environments/norails/Gemfile

@@ -8,6 +8,9 @@ gem 'rack-test'
 
 platforms :rbx do
   gem "rubysl"
+  gem "rubysl-test-unit"
+  gem "rubysl-json"
+  gem "psych"
   gem "racc"  # https://github.com/rubinius/rubinius/issues/2632
 end
 

data/test/environments/rails40/Gemfile

@@ -14,7 +14,7 @@ platforms :jruby do
   gem "jruby-openssl"
 end
 
-platforms :mri_19, :mri_20, :rbx do
+platforms :ruby do
   gem "mysql"
   gem "sqlite3-ruby"
   gem "sqlite3"
@@ -22,6 +22,10 @@ end
 
 platforms :rbx do
   gem "rubysl"
+  gem "rubysl-json"
+  # If we don't skip the require here, test-unit tries to install its at_exit
+  # hook and run when we run our rake task to create the test DB.
+  gem "rubysl-test-unit", :require => false
   gem "racc"  # https://github.com/rubinius/rubinius/issues/2632
 end
 

data/test/flaky_proxy/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gem 'http_parser.rb'

data/test/flaky_proxy/README.md

@@ -0,0 +1,82 @@
+## flaky_proxy
+
+`flaky_proxy` helps you simulate failures in an HTTP service in a configurable
+way, without modifying the underlying service.
+
+## Usage
+
+```
+flaky_proxy -l 8888 -t 8081 rules
+```
+
+Where `rules` is a file with the following content:
+
+```
+match /foo/ { close }
+
+match /bar/ do
+  close
+  pass
+end
+
+match /baz/ do
+  respond :status => 503
+  respond :body => '{ "error": "bad things happened" }'
+  pass
+end
+
+match /slowdown/ do
+  delay 10
+end
+```
+
+This will instruct `flaky_proxy` to listen for incoming connections on port
+8888, and forward HTTP requests recieved on this port on to the server running
+on localhost on port 8081.
+
+Incoming requests will be evaluated against the match rules specified in the
+`rules` file that you pass to `flaky_proxy`. Each call to `match` takes a Regexp
+and a block.
+
+The Regexp is evaluated against the URL on the incoming request to
+determine whether the rule matches a given request. Each request will be handled
+by the *first* matching rule (or the default rule if no matches are found).
+
+The block passed to `match` should contain a sequence of *actions* for handling
+matching requests. Actions will be applied in sequence (the first matching
+request will get the first action, the second will get the second, and so on).
+Once all of the actions have been evaluated, the final action in the block will
+continue to be used.
+
+The `rules` file will be watched for changes automatically, and the rules will
+be potentially reloaded each time the proxy accepts a new connection.
+
+If the `rules` file is omitted, the all requests will be transparently proxied to the backend server. 
+
+### Available Actions
+
+#### pass
+
+Pass the request on to the backend server without modification.
+
+#### close
+
+Close the TCP connection from the client before forwarding it on to the backend server.
+
+#### respond(response_spec)
+
+Respond to the client with a canned response, instead of forwarding the request on to the backend server. `response_spec` should be a `Hash` describing the canned response to be sent to the client. Recognized keys in the `response_spec` are:
+
+* `:status` - A `Fixnum` with the HTTP status code. Default: 200.
+* `:headers` - A `Hash` with response headers. Default: the `Content-Length` header will be automatically set based on the response body length.
+* `:body` - A `String` containing the HTTP response body. Default = `''`.
+
+#### delay(amount)
+
+Delay for `amount` seconds before forwarding the request on to the backend server.
+
+## Caveats
+
+* Totally single-threaded and non-evented, therefore cannot handle multiple client connections at once.
+* Errors introduced in the rules file will likely the process to crash instead of just printing an error.
+* Almost certainly doesn't handle string encodings correctly