newrelic_rpm 3.15.1.316 → 3.15.2.317

data/lib/new_relic/agent/database/obfuscation_helpers.rb

@@ -40,6 +40,7 @@ module NewRelic
         # placeholder.
         CLEANUP_REGEX = {
           :mysql => /'|"|\/\*|\*\//,
+          :mysql2 => /'|"|\/\*|\*\//,
           :postgres => /'|\/\*|\*\/|\$(?!\?)/,
           :sqlite => /'|\/\*|\*\//,
           :cassandra => /'|\/\*|\*\//,
@@ -68,7 +69,7 @@ module NewRelic
 
         def obfuscate(sql, adapter)
           case adapter
-          when :mysql
+          when :mysql, :mysql2
             regex = MYSQL_COMPONENTS_REGEX
           when :postgres
             regex = POSTGRES_COMPONENTS_REGEX

data/lib/new_relic/agent/database/postgres_explain_obfuscator.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/database/obfuscation_helpers'
-
 module NewRelic
   module Agent
     module Database

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

@@ -6,13 +6,13 @@ module NewRelic
   module Agent
     module Instrumentation
       module ActiveRecord
-        EXPLAINER = lambda do |config, query|
-          connection = NewRelic::Agent::Database.get_connection(config) do
-            ::ActiveRecord::Base.send("#{config[:adapter]}_connection",
-                                      config)
+        EXPLAINER = lambda do |statement|
+          connection = NewRelic::Agent::Database.get_connection(statement.config) do
+            ::ActiveRecord::Base.send("#{statement.config[:adapter]}_connection",
+                                      statement.config)
           end
           if connection && connection.respond_to?(:execute)
-            return connection.execute("EXPLAIN #{query}")
+            return connection.execute("EXPLAIN #{statement.sql}")
           end
         end
 

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

@@ -40,13 +40,15 @@ module NewRelic
           log_notification_error(e, name, 'finish')
         end
 
-        def get_explain_plan( config, query )
-          connection = NewRelic::Agent::Database.get_connection(config) do
-            ::ActiveRecord::Base.send("#{config[:adapter]}_connection",
-                                      config)
+        def get_explain_plan(statement)
+          connection = NewRelic::Agent::Database.get_connection(statement.config) do
+            ::ActiveRecord::Base.send("#{statement.config[:adapter]}_connection",
+                                      statement.config)
           end
-          if connection && connection.respond_to?(:execute)
-            return connection.execute("EXPLAIN #{query}")
+          if connection && connection.respond_to?(:exec_query)
+            return connection.exec_query("EXPLAIN #{statement.sql}",
+                                         "Explain #{statement.name}",
+                                         statement.binds)
           end
         end
 
@@ -59,12 +61,12 @@ module NewRelic
           NewRelic::Agent.instance.transaction_sampler \
             .notice_sql(event.payload[:sql], config,
                         Helper.milliseconds_to_seconds(event.duration),
-                        state, @explainer)
+                        state, @explainer, event.payload[:binds], event.payload[:name])
 
           NewRelic::Agent.instance.sql_sampler \
             .notice_sql(event.payload[:sql], metric, config,
                         Helper.milliseconds_to_seconds(event.duration),
-                        state, @explainer)
+                        state, @explainer, event.payload[:binds], event.payload[:name])
 
           # exit transaction trace node
           stack.pop_frame(state, frame, metric, event.end)

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

@@ -147,7 +147,8 @@ module NewRelic
                 strategy = NewRelic::Agent::Database.record_sql_method(:slow_sql)
                 case strategy
                 when :obfuscated
-                  statement = NewRelic::Agent::Database::Statement.new(e.query, :adapter => self.options[:adapter])
+                  adapter_name = self.respond_to?(:options) ? self.options[:adapter] : self.repository.adapter.uri.scheme
+                  statement = NewRelic::Agent::Database::Statement.new(e.query, :adapter => adapter_name)
                   obfuscated_sql = NewRelic::Agent::Database.obfuscate_sql(statement)
                   e.instance_variable_set(:@query, obfuscated_sql)
                 when :off

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

@@ -28,15 +28,29 @@ module NewRelic
           Transaction.set_default_transaction_name(txn_name, :grape, node_name)
         end
 
-        def name_for_transaction(route, class_name)
-          action_name = route.route_path.sub(FORMAT_REGEX, EMPTY_STRING)
-          method_name = route.route_method
-
-          if route.route_version
-            action_name = action_name.sub(VERSION_REGEX, EMPTY_STRING)
-            "#{class_name}-#{route.route_version}#{action_name} (#{method_name})"
-          else
-            "#{class_name}#{action_name} (#{method_name})"
+        if defined?(Grape::VERSION) && VersionNumber.new(::Grape::VERSION) >= VersionNumber.new("0.16.0")
+          def name_for_transaction(route, class_name)
+            action_name = route.path.sub(FORMAT_REGEX, EMPTY_STRING)
+            method_name = route.request_method
+
+            if route.version
+              action_name = action_name.sub(VERSION_REGEX, EMPTY_STRING)
+              "#{class_name}-#{route.version}#{action_name} (#{method_name})"
+            else
+              "#{class_name}#{action_name} (#{method_name})"
+            end
+          end
+        else
+          def name_for_transaction(route, class_name)
+            action_name = route.route_path.sub(FORMAT_REGEX, EMPTY_STRING)
+            method_name = route.route_method
+
+            if route.route_version
+              action_name = action_name.sub(VERSION_REGEX, EMPTY_STRING)
+              "#{class_name}-#{route.route_version}#{action_name} (#{method_name})"
+            else
+              "#{class_name}#{action_name} (#{method_name})"
+            end
           end
         end
 

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

@@ -9,7 +9,6 @@ module NewRelic
       class MongodbCommandSubscriber
 
         MONGODB = 'MongoDB'.freeze
-        GET_MORE = "getMore".freeze
         COLLECTION = "collection".freeze
 
         def started(event)
@@ -45,11 +44,7 @@ module NewRelic
         private
 
         def collection(event)
-          if event.command_name == GET_MORE
-            event.command[COLLECTION]
-          else
-            event.command.values.first
-          end
+          event.command[COLLECTION] || event.command[:collection] || event.command.values.first
         end
 
         def metrics(event)

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

@@ -27,6 +27,42 @@ DependencyDetection.defer do
 
       alias dispatch_without_newrelic dispatch!
       alias dispatch! dispatch_with_newrelic
+
+      # Padrino 0.13 mustermann routing
+      if private_method_defined?(:invoke_route)
+        include NewRelic::Agent::Instrumentation::Padrino
+
+        alias invoke_route_without_newrelic invoke_route
+        alias invoke_route invoke_route_with_newrelic
+      end
+    end
+  end
+end
+
+module NewRelic
+  module Agent
+    module Instrumentation
+      module Padrino
+        def invoke_route_with_newrelic(*args, &block)
+          begin
+            env["newrelic.last_route"] = args[0].original_path
+          rescue => e
+            ::NewRelic::Agent.logger.debug("Failed determining last route in Padrino", e)
+          end
+
+          begin
+            txn_name = ::NewRelic::Agent::Instrumentation::Sinatra::TransactionNamer.transaction_name_for_route(env, request)
+            unless txn_name.nil?
+              ::NewRelic::Agent::Transaction.set_default_transaction_name(
+                "#{self.class.name}/#{txn_name}", :sinatra)
+            end
+          rescue => e
+            ::NewRelic::Agent.logger.debug("Failed during invoke_route to set transaction name", e)
+          end
+
+          invoke_route_without_newrelic(*args, &block)
+        end
+      end
     end
   end
 end

data/lib/new_relic/agent/method_tracer.rb

@@ -202,7 +202,7 @@ module NewRelic
           # Example:
           #  Foo.default_metric_name_code('bar') #=> "Custom/#{Foo.name}/bar"
           def default_metric_name_code(method_name)
-            "Custom/#{class_name}/#{method_name}"
+            "Custom/#{derived_class_name}/#{method_name}"
           end
 
           # Checks to see if the method we are attempting to trace
@@ -210,7 +210,7 @@ module NewRelic
           # anything if the method doesn't exist.
           def newrelic_method_exists?(method_name)
             exists = method_defined?(method_name) || private_method_defined?(method_name)
-            ::NewRelic::Agent.logger.error("Did not trace #{class_name}##{method_name} because that method does not exist") unless exists
+            ::NewRelic::Agent.logger.error("Did not trace #{derived_class_name}##{method_name} because that method does not exist") unless exists
             exists
           end
 
@@ -275,6 +275,23 @@ module NewRelic
               method_without_push_scope(method_name, metric_name_code, options)
             end
           end
+
+          private
+
+          def derived_class_name
+            return self.name if self.name && !self.name.empty?
+            return "AnonymousModule" if self.to_s.start_with?("#<Module:")
+
+            # trying to get the "MyClass" portion of "#<Class:MyClass>"
+            name = self.to_s[/^#<Class:(.+)>$/, 1]
+            if name.start_with?("0x")
+              "AnonymousClass"
+            elsif name.start_with?("#<Class:")
+              "AnonymousClass/Class"
+            else
+              "#{name}/Class"
+            end
+          end
         end
         include AddMethodTracer
 
@@ -345,7 +362,7 @@ module NewRelic
           alias_method method_name, _traced_method_name(method_name, metric_name_code)
           send visibility, method_name
           send visibility, _traced_method_name(method_name, metric_name_code)
-          ::NewRelic::Agent.logger.debug("Traced method: class = #{class_name},"+
+          ::NewRelic::Agent.logger.debug("Traced method: class = #{derived_class_name},"+
                     "method = #{method_name}, "+
                     "metric = '#{metric_name_code}'")
         end
@@ -383,21 +400,6 @@ module NewRelic
         def _sanitize_name(name)
           name.to_s.tr_s('^a-zA-Z0-9', '_')
         end
-
-        def class_name
-          return self.name if self.name && !self.name.empty?
-          return "AnonymousModule" if self.to_s.start_with?("#<Module:")
-
-          # trying to get the "MyClass" portion of "#<Class:MyClass>"
-          name = self.to_s[/^#<Class:(.+)>$/, 1]
-          if name.start_with?("0x")
-            "AnonymousClass"
-          elsif name.start_with?("#<Class:")
-            "AnonymousClass/Class"
-          else
-            "#{name}/Class"
-          end
-        end
       end
 
       # @!parse extend ClassMethods

data/lib/new_relic/agent/new_relic_service.rb

@@ -30,13 +30,12 @@ module NewRelic
       CONNECTION_ERRORS = [Timeout::Error, EOFError, SystemCallError, SocketError].freeze
 
       attr_accessor :request_timeout, :agent_id
-      attr_reader :collector, :marshaller, :metric_id_cache
+      attr_reader :collector, :marshaller
 
       def initialize(license_key=nil, collector=control.server)
         @license_key = license_key || Agent.config[:license_key]
         @collector = collector
         @request_timeout = Agent.config[:timeout]
-        @metric_id_cache = {}
         @ssl_cert_store = nil
         @in_session = nil
         @agent_id = nil
@@ -80,46 +79,18 @@ module NewRelic
         invoke_remote(:shutdown, [@agent_id, time.to_i]) if @agent_id
       end
 
-      def reset_metric_id_cache
-        @metric_id_cache = {}
-      end
-
       def force_restart
-        reset_metric_id_cache
         close_shared_connection
       end
 
-      # takes an array of arrays of spec and id, adds it into the
-      # metric cache so we can save the collector some work by
-      # sending integers instead of strings the next time around
-      def fill_metric_id_cache(pairs_of_specs_and_ids)
-        Array(pairs_of_specs_and_ids).each do |metric_spec_hash, metric_id|
-          metric_spec = MetricSpec.new(metric_spec_hash['name'],
-                                       metric_spec_hash['scope'])
-          metric_id_cache[metric_spec] = metric_id
-        end
-      rescue => e
-        # If we've gotten this far, we don't want this error to propagate and
-        # make this post appear to have been non-successful, which would trigger
-        # re-aggregation of the same metric data into the next post, so just log
-        NewRelic::Agent.logger.error("Failed to fill metric ID cache from response, error details follow ", e)
-      end
-
-      # The collector wants to recieve metric data in a format that's different
+      # The collector wants to receive metric data in a format that's different
       # from how we store it internally, so this method handles the translation.
-      # It also handles translating metric names to IDs using our metric ID cache.
       def build_metric_data_array(stats_hash)
         metric_data_array = []
         stats_hash.each do |metric_spec, stats|
           # Omit empty stats as an optimization
           unless stats.is_reset?
-            metric_id = metric_id_cache[metric_spec]
-            metric_data = if metric_id
-              NewRelic::MetricData.new(nil, stats, metric_id)
-            else
-              NewRelic::MetricData.new(metric_spec, stats, nil)
-            end
-            metric_data_array << metric_data
+            metric_data_array << NewRelic::MetricData.new(metric_spec, stats)
           end
         end
         metric_data_array
@@ -134,7 +105,6 @@ module NewRelic
           [@agent_id, timeslice_start.to_f, timeslice_end.to_f, metric_data_array],
           :item_count => metric_data_array.size
         )
-        fill_metric_id_cache(result)
         result
       end
 

data/lib/new_relic/agent/pipe_service.rb

@@ -68,10 +68,6 @@ module NewRelic
         yield
       end
 
-      def reset_metric_id_cache
-        # we don't cache metric IDs, so nothing to do
-      end
-
       private
 
       def marshal_payload(data)

data/lib/new_relic/agent/sql_sampler.rb

@@ -140,7 +140,7 @@ module NewRelic
       # @api public
       # @deprecated Use {Datastores.notice_sql} instead.
       #
-      def notice_sql(sql, metric_name, config, duration, state=nil, explainer=nil) #THREAD_LOCAL_ACCESS sometimes
+      def notice_sql(sql, metric_name, config, duration, state=nil, explainer=nil, binds=[], name="SQL") #THREAD_LOCAL_ACCESS sometimes
         state ||= TransactionState.tl_get
         data = state.sql_sampler_transaction_data
         return unless data
@@ -148,7 +148,7 @@ module NewRelic
         if state.is_sql_recorded?
           if duration > Agent.config[:'slow_sql.explain_threshold']
             backtrace = caller.join("\n")
-            statement = Database::Statement.new(sql, config, explainer)
+            statement = Database::Statement.new(sql, config, explainer, binds, name)
             data.sql_data << SlowSql.new(statement, metric_name, duration, backtrace)
           end
         end
@@ -234,7 +234,7 @@ module NewRelic
 
       def explain
         if statement.config && statement.explainer
-          NewRelic::Agent::Database.explain_sql(statement.sql, statement.config, statement.explainer)
+          NewRelic::Agent::Database.explain_sql(statement)
         end
       end
 

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

@@ -165,12 +165,9 @@ module NewRelic
           return params[:explain_plan] if params.key?(:explain_plan)
 
           statement = params[:sql]
-          return nil unless statement.respond_to?(:config) &&
-            statement.respond_to?(:explainer)
+          return nil unless statement.is_a?(Database::Statement)
 
-          NewRelic::Agent::Database.explain_sql(statement.sql,
-                                                statement.config,
-                                                statement.explainer)
+          NewRelic::Agent::Database.explain_sql(statement)
         end
 
         def obfuscated_sql

data/lib/new_relic/agent/transaction_sampler.rb

@@ -183,13 +183,13 @@ module NewRelic
       # @api public
       # @deprecated Use {Datastores.notice_sql} instead.
       #
-      def notice_sql(sql, config, duration, state=nil, explainer=nil) #THREAD_LOCAL_ACCESS sometimes
+      def notice_sql(sql, config, duration, state=nil, explainer=nil, binds=[], name="SQL") #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
         builder = state.transaction_sample_builder
         if state.is_sql_recorded?
-          statement = Database::Statement.new(sql, config, explainer)
+          statement = Database::Statement.new(sql, config, explainer, binds, name)
           notice_extra_data(builder, statement, duration, :sql)
         end
       end

data/lib/new_relic/metric_data.rb

@@ -6,17 +6,14 @@ require 'new_relic/coerce'
 
 module NewRelic
   class MetricData
-    # nil, or a NewRelic::MetricSpec object if we have no cached ID
+    # a NewRelic::MetricSpec object
     attr_reader :metric_spec
-    # nil or a cached integer ID for the metric from the collector.
-    attr_accessor :metric_id
     # the actual statistics object
     attr_accessor :stats
 
-    def initialize(metric_spec, stats, metric_id)
+    def initialize(metric_spec, stats)
       @metric_spec = metric_spec
       self.stats = stats
-      self.metric_id = metric_id
     end
 
     def eql?(o)
@@ -38,27 +35,22 @@ module NewRelic
       metric_spec.hash ^ stats.hash
     end
 
-    # Serialize with all attributes, but if the metric id is not nil, then don't send the metric spec
     def to_json(*a)
-       %Q[{"metric_spec":#{metric_id ? 'null' : metric_spec.to_json},"stats":{"total_exclusive_time":#{stats.total_exclusive_time},"min_call_time":#{stats.min_call_time},"call_count":#{stats.call_count},"sum_of_squares":#{stats.sum_of_squares},"total_call_time":#{stats.total_call_time},"max_call_time":#{stats.max_call_time}},"metric_id":#{metric_id ? metric_id : 'null'}}]
+       %Q[{"metric_spec":#{metric_spec.to_json},"stats":{"total_exclusive_time":#{stats.total_exclusive_time},"min_call_time":#{stats.min_call_time},"call_count":#{stats.call_count},"sum_of_squares":#{stats.sum_of_squares},"total_call_time":#{stats.total_call_time},"max_call_time":#{stats.max_call_time}}}]
     end
 
     def to_s
-      if metric_spec
-        "#{metric_spec.name}(#{metric_spec.scope}): #{stats}"
-      else
-        "#{metric_id}: #{stats}"
-      end
+      "#{metric_spec.name}(#{metric_spec.scope}): #{stats}"
     end
 
     def inspect
-      "#<MetricData metric_spec:#{metric_spec.inspect}, stats:#{stats.inspect}, metric_id:#{metric_id.inspect}>"
+      "#<MetricData metric_spec:#{metric_spec.inspect}, stats:#{stats.inspect}>"
     end
 
     include NewRelic::Coerce
 
     def to_collector_array(encoder=nil)
-      stat_key = metric_id || { 'name' => metric_spec.name, 'scope' => metric_spec.scope }
+      stat_key = { 'name' => metric_spec.name, 'scope' => metric_spec.scope }
       [ stat_key,
         [
           int(stats.call_count, stat_key),