newrelic_rpm 3.12.1.298 → 3.13.0.299

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

@@ -3,6 +3,7 @@
 # See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
 require 'new_relic/agent/instrumentation/evented_subscriber'
 require 'new_relic/agent/instrumentation/ignore_actions'
+require 'new_relic/agent/parameter_filtering'
 
 module NewRelic
   module Agent

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

@@ -235,6 +235,7 @@ module NewRelic
             when :sinatra    then ::NewRelic::Agent::Transaction::SINATRA_PREFIX
             when :middleware then ::NewRelic::Agent::Transaction::MIDDLEWARE_PREFIX
             when :grape      then ::NewRelic::Agent::Transaction::GRAPE_PREFIX
+            when :rake       then ::NewRelic::Agent::Transaction::RAKE_PREFIX
             else "#{category.to_s}/" # for internal use only
             end
           end

data/lib/new_relic/agent/instrumentation/rails/action_controller.rb

@@ -2,6 +2,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/parameter_filtering'
+
 DependencyDetection.defer do
   @name = :rails21_view
 

data/lib/new_relic/agent/instrumentation/rails3/action_controller.rb

@@ -2,6 +2,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/parameter_filtering'
+
 module NewRelic
   module Agent
     module Instrumentation

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

@@ -0,0 +1,170 @@
+# 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
+  # Why not :rake? newrelic-rake used that name, so avoid conflicting
+  named :rake_instrumentation
+
+  depends_on do
+    defined?(::Rake) &&
+      ::NewRelic::Agent.config[:'disable_rake'] == false &&
+      ::NewRelic::Agent.config[:'rake.tasks'].any? &&
+      ::NewRelic::Agent::Instrumentation::RakeInstrumentation.should_install?
+  end
+
+  executes do
+    ::NewRelic::Agent.logger.info  "Installing Rake instrumentation"
+    ::NewRelic::Agent.logger.debug "Instrumenting Rake tasks: #{::NewRelic::Agent.config[:'rake.tasks']}"
+  end
+
+  executes do
+    module Rake
+      class Task
+        alias_method :invoke_without_newrelic, :invoke
+
+        def invoke(*args)
+          unless NewRelic::Agent::Instrumentation::RakeInstrumentation.should_trace? name
+            return invoke_without_newrelic(*args)
+          end
+
+          begin
+            timeout = NewRelic::Agent.config[:'rake.connect_timeout']
+            NewRelic::Agent.instance.wait_on_connect(timeout)
+          rescue => e
+            NewRelic::Agent.logger.error("Exception in wait_on_connect", e)
+            return invoke_without_newrelic(*args)
+          end
+
+          NewRelic::Agent::Instrumentation::RakeInstrumentation.before_invoke_transaction(self)
+
+          state = NewRelic::Agent::TransactionState.tl_get
+          NewRelic::Agent::Transaction.wrap(state, "OtherTransaction/Rake/invoke/#{name}", :rake)  do
+            NewRelic::Agent::Instrumentation::RakeInstrumentation.record_attributes(args, self)
+            invoke_without_newrelic(*args)
+          end
+        end
+      end
+    end
+  end
+end
+
+module NewRelic
+  module Agent
+    module Instrumentation
+      module RakeInstrumentation
+        def self.should_install?
+          is_supported_version? && safe_from_third_party_gem?
+        end
+
+        def self.is_supported_version?
+          ::NewRelic::VersionNumber.new(::Rake::VERSION) >= ::NewRelic::VersionNumber.new("10.0.0")
+        end
+
+        def self.safe_from_third_party_gem?
+          if NewRelic::LanguageSupport.bundled_gem?("newrelic-rake")
+            ::NewRelic::Agent.logger.info("Not installing New Relic supported Rake instrumentation because the third party newrelic-rake gem is present")
+            false
+          else
+            true
+          end
+        end
+
+        def self.should_trace?(name)
+          NewRelic::Agent.config[:'rake.tasks'].any? do |regex|
+            regex.match(name)
+          end
+        end
+
+        def self.instrument_execute_on_prereqs(task)
+          task.prerequisite_tasks.each do |child_task|
+            instrument_execute(child_task)
+          end
+        end
+
+        def self.instrument_execute(task)
+          return if task.instance_variable_get(:@__newrelic_instrumented_execute)
+
+          task.instance_variable_set(:@__newrelic_instrumented_execute, true)
+          task.instance_eval do
+            def execute(*args, &block)
+              NewRelic::Agent::MethodTracer.trace_execution_scoped("Rake/execute/#{self.name}") do
+                super
+              end
+            end
+          end
+
+          instrument_execute_on_prereqs(task)
+        end
+
+        def self.instrument_invoke_prerequisites_concurrently(task)
+          task.instance_eval do
+            def invoke_prerequisites_concurrently(*_)
+              NewRelic::Agent::MethodTracer.trace_execution_scoped("Rake/execute/multitask") do
+                prereqs = self.prerequisite_tasks.map(&:name).join(", ")
+                NewRelic::Agent::Datastores.notice_statement("Couldn't trace concurrent prereq tasks: #{prereqs}", 0)
+                super
+              end
+            end
+          end
+        end
+
+        def self.before_invoke_transaction(task)
+          ensure_at_exit
+
+          # We can't represent overlapping operations yet, so if multitask just
+          # make one node and annotate with prereq task names
+          if task.application.options.always_multitask
+            instrument_invoke_prerequisites_concurrently(task)
+          else
+            instrument_execute_on_prereqs(task)
+          end
+        rescue => e
+          NewRelic::Agent.logger.error("Error during Rake task invoke", e)
+        end
+
+        def self.record_attributes(args, task)
+          command_line = task.application.top_level_tasks.join(" ")
+          NewRelic::Agent::Transaction.merge_untrusted_agent_attributes({ :command => command_line },
+                                                                        :'job.rake',
+                                                                        NewRelic::Agent::AttributeFilter::DST_NONE)
+          named_args = name_the_args(args, task.arg_names)
+          unless named_args.empty?
+            NewRelic::Agent::Transaction.merge_untrusted_agent_attributes(named_args,
+                                                                          :'job.rake.args',
+                                                                          NewRelic::Agent::AttributeFilter::DST_NONE)
+          end
+        rescue => e
+          NewRelic::Agent.logger.error("Error during Rake task attribute recording.", e)
+        end
+
+        # Expects literal args passed to the task and array of task names
+        # If names are present without matching args, still sets them with nils
+        def self.name_the_args(args, names)
+          unfulfilled_names_length = names.length - args.length
+          if unfulfilled_names_length > 0
+            args.concat(Array.new(unfulfilled_names_length))
+          end
+
+          result = {}
+          args.zip(names).each_with_index do |(value, key), index|
+            result[key || index.to_s] = value
+          end
+          result
+        end
+
+        def self.ensure_at_exit
+          return if @installed_at_exit
+
+          at_exit do
+            # The agent's default at_exit might not default to installing, but
+            # if we are running an instrumented rake task, we always want it.
+            NewRelic::Agent.shutdown
+          end
+
+          @installed_at_exit = true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+# 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'
+require 'new_relic/agent/datastores/redis'
+
+DependencyDetection.defer do
+  # Why not :redis? newrelic-redis used that name, so avoid conflicting
+  named :redis_instrumentation
+
+  depends_on do
+    defined? ::Redis
+  end
+
+  depends_on do
+    NewRelic::Agent.config[:disable_redis] == false
+  end
+
+  depends_on do
+    NewRelic::Agent::Datastores::Redis.is_supported_version? &&
+      NewRelic::Agent::Datastores::Redis.safe_from_third_party_gem?
+  end
+
+  executes do
+    NewRelic::Agent.logger.info 'Installing Redis Instrumentation'
+
+    Redis::Client.class_eval do
+      alias_method :call_without_new_relic, :call
+
+      def call(*args, &block)
+        operation = args[0][0]
+        statement = ::NewRelic::Agent::Datastores::Redis.format_command(args[0])
+
+        if statement
+          callback = Proc.new do |result, _, elapsed|
+            NewRelic::Agent::Datastores.notice_statement(statement, elapsed)
+          end
+        end
+
+        NewRelic::Agent::Datastores.wrap(NewRelic::Agent::Datastores::Redis::PRODUCT_NAME, operation, nil, callback) do
+          call_without_new_relic(*args, &block)
+        end
+      end
+
+      alias_method :call_pipeline_without_new_relic, :call_pipeline
+
+      def call_pipeline(*args, &block)
+        pipeline = args[0]
+        operation = pipeline.is_a?(::Redis::Pipeline::Multi) ? NewRelic::Agent::Datastores::Redis::MULTI_OPERATION : NewRelic::Agent::Datastores::Redis::PIPELINE_OPERATION
+        statement = ::NewRelic::Agent::Datastores::Redis.format_pipeline_commands(pipeline.commands)
+
+        callback = Proc.new do |result, _, elapsed|
+          NewRelic::Agent::Datastores.notice_statement(statement, elapsed)
+        end
+
+        NewRelic::Agent::Datastores.wrap(NewRelic::Agent::Datastores::Redis::PRODUCT_NAME, operation, nil, callback) do
+          call_pipeline_without_new_relic(*args, &block)
+        end
+      end
+
+      alias_method :connect_without_new_relic, :connect
+
+      def connect(*args, &block)
+        NewRelic::Agent::Datastores.wrap(NewRelic::Agent::Datastores::Redis::PRODUCT_NAME, NewRelic::Agent::Datastores::Redis::CONNECT) do
+          connect_without_new_relic(*args, &block)
+        end
+      end
+    end
+  end
+end

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

@@ -5,6 +5,7 @@
 require 'new_relic/agent/instrumentation/controller_instrumentation'
 require 'new_relic/agent/instrumentation/sinatra/transaction_namer'
 require 'new_relic/agent/instrumentation/sinatra/ignorer'
+require 'new_relic/agent/parameter_filtering'
 
 DependencyDetection.defer do
   @name = :sinatra

data/lib/new_relic/agent/new_relic_service.rb

@@ -38,6 +38,10 @@ module NewRelic
         @collector = collector
         @request_timeout = Agent.config[:timeout]
         @metric_id_cache = {}
+        @ssl_cert_store = nil
+        @in_session = nil
+        @agent_id = nil
+        @shared_tcp_connection = nil
 
         @audit_logger = ::NewRelic::Agent::AuditLogger.new
         Agent.config.register_callback(:'audit_log.enabled') do |enabled|

data/lib/new_relic/agent/sql_sampler.rb

@@ -148,9 +148,8 @@ module NewRelic
         if state.is_sql_recorded?
           if duration > Agent.config[:'slow_sql.explain_threshold']
             backtrace = caller.join("\n")
-            data.sql_data << SlowSql.new(Database.capture_query(sql),
-                                         metric_name, config,
-                                         duration, backtrace, explainer)
+            statement = Database::Statement.new(sql, config, explainer)
+            data.sql_data << SlowSql.new(statement, metric_name, duration, backtrace)
           end
         end
       end
@@ -208,38 +207,40 @@ module NewRelic
     end
 
     class SlowSql
-      attr_reader :sql
+      attr_reader :statement
       attr_reader :metric_name
       attr_reader :duration
       attr_reader :backtrace
 
-      def initialize(sql, metric_name, config, duration, backtrace=nil, explainer=nil)
-        @sql = sql
+      def initialize(statement, metric_name, duration, backtrace=nil)
+        @statement = statement
         @metric_name = metric_name
-        @config = config
         @duration = duration
         @backtrace = backtrace
-        @explainer = explainer
+      end
+
+      def sql
+        statement.sql
       end
 
       def obfuscate
-        NewRelic::Agent::Database.obfuscate_sql(@sql)
+        NewRelic::Agent::Database.obfuscate_sql(statement)
       end
 
       def normalize
         NewRelic::Agent::Database::Obfuscator.instance \
-          .default_sql_obfuscator(@sql).gsub(/\?\s*\,\s*/, '').gsub(/\s/, '')
+          .default_sql_obfuscator(statement).gsub(/\?\s*\,\s*/, '').gsub(/\s/, '')
       end
 
       def explain
-        if @config && @explainer
-          NewRelic::Agent::Database.explain_sql(@sql, @config, @explainer)
+        if statement.config && statement.explainer
+          NewRelic::Agent::Database.explain_sql(statement.sql, statement.config, statement.explainer)
         end
       end
 
       # We can't serialize the explainer, so clear it before we transmit
       def prepare_to_send
-        @explainer = nil
+        statement.explainer = nil
       end
     end
 

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

@@ -10,6 +10,7 @@ module NewRelic
         GCSnapshot = Struct.new(:gc_time_s, :gc_call_count)
 
         def self.init
+          @initialized ||= nil
           return @profiler if @initialized
           @profiler = if RailsBenchProfiler.enabled?
             RailsBenchProfiler.new

data/lib/new_relic/agent/transaction.rb

@@ -21,6 +21,7 @@ module NewRelic
       CONTROLLER_PREFIX            = 'Controller/'.freeze
       MIDDLEWARE_PREFIX            = 'Middleware/Rack/'.freeze
       TASK_PREFIX                  = 'OtherTransaction/Background/'.freeze
+      RAKE_PREFIX                  = 'OtherTransaction/Rake/'.freeze
       RACK_PREFIX                  = 'Controller/Rack/'.freeze
       SINATRA_PREFIX               = 'Controller/Sinatra/'.freeze
       GRAPE_PREFIX                 = 'Controller/Grape/'.freeze
@@ -279,6 +280,7 @@ module NewRelic
         @ignore_this_transaction = false
         @ignore_apdex = false
         @ignore_enduser = false
+        @ignore_trace = false
 
         @attributes = Attributes.new(NewRelic::Agent.instance.attribute_filter)
 

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

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

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

@@ -19,6 +19,7 @@ module NewRelic
           @start_time = start_time
           @node_count = 0
           @root_node = NewRelic::Agent::Transaction::TraceNode.new(0.0, "ROOT")
+          @prepared = false
         end
 
         def sample_id
@@ -91,7 +92,7 @@ module NewRelic
             when :obfuscated
               node[:sql] = NewRelic::Agent::Database.obfuscate_sql(node[:sql])
             when :raw
-              node[:sql] = node[:sql].to_s
+              node[:sql] = node[:sql].sql.to_s
             else
               node[:sql] = nil
             end

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

@@ -19,6 +19,7 @@ module NewRelic
         def initialize(timestamp, metric_name)
           @entry_timestamp = timestamp
           @metric_name     = metric_name || UNKNOWN_NODE_NAME
+          @called_nodes    = nil
         end
 
         # sets the final timestamp on a node to indicate the exit
@@ -167,13 +168,13 @@ module NewRelic
           return nil unless statement.respond_to?(:config) &&
             statement.respond_to?(:explainer)
 
-          NewRelic::Agent::Database.explain_sql(statement,
+          NewRelic::Agent::Database.explain_sql(statement.sql,
                                                 statement.config,
                                                 statement.explainer)
         end
 
         def obfuscated_sql
-          NewRelic::Agent::Database.obfuscate_sql(params[:sql])
+          NewRelic::Agent::Database.obfuscate_sql(params[:sql].sql)
         end
 
         def called_nodes=(nodes)

data/lib/new_relic/agent/transaction_sampler.rb

@@ -132,9 +132,9 @@ module NewRelic
         node = builder.current_node
         if node
           if key == :sql
-            sql = node[:sql]
-            if(sql && !sql.empty?)
-              sql = self.class.truncate_message(sql << "\n#{message}") if sql.length <= MAX_DATA_LENGTH
+            statement = node[:sql]
+            if(statement && !statement.sql.empty?)
+              statement.sql = self.class.truncate_message(statement.sql + "\n#{message.sql}") if statement.sql.length <= MAX_DATA_LENGTH
             else
               # message is expected to have been pre-truncated by notice_sql
               node[:sql] = message
@@ -189,22 +189,11 @@ module NewRelic
         state ||= TransactionState.tl_get
         builder = state.transaction_sample_builder
         if state.is_sql_recorded?
-          statement = build_database_statement(sql, config, explainer)
+          statement = Database::Statement.new(sql, config, explainer)
           notice_extra_data(builder, statement, duration, :sql)
         end
       end
 
-      def build_database_statement(sql, config, explainer)
-        statement = Database::Statement.new(Database.capture_query(sql))
-        if config
-          statement.adapter = config[:adapter]
-          statement.config = config
-        end
-        statement.explainer = explainer
-
-        statement
-      end
-
       # Attaches an additional non-SQL query parameter to the current
       # transaction trace node.
       #