newrelic_rpm 6.14.0 → 6.15.0

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

@@ -55,158 +55,79 @@ DependencyDetection.defer do
     Redis::Client.class_eval do
       alias_method :call_without_new_relic, :call
 
-      if RUBY_VERSION < "2.7.0"
-        def call(*args, &block)
-          operation = args[0][0]
-          statement = ::NewRelic::Agent::Datastores::Redis.format_command(args[0])
-  
-          hostname = NewRelic::Agent::Instrumentation::Redis.host_for(self)
-          port_path_or_id = NewRelic::Agent::Instrumentation::Redis.port_path_or_id_for(self)
-  
-          segment = NewRelic::Agent::Tracer.start_datastore_segment(
-            product: NewRelic::Agent::Datastores::Redis::PRODUCT_NAME,
-            operation: operation,
-            host: hostname,
-            port_path_or_id: port_path_or_id,
-            database_name: db
-          )
-          begin
-            segment.notice_nosql_statement(statement) if statement
-            NewRelic::Agent::Tracer.capture_segment_error segment do
-              call_without_new_relic(*args, &block)
-            end
-          ensure
-            segment.finish if segment
-          end
-        end
-      else
-        def call(*args, **kwargs, &block)
-          operation = args[0][0]
-          statement = ::NewRelic::Agent::Datastores::Redis.format_command(args[0])
-  
-          hostname = NewRelic::Agent::Instrumentation::Redis.host_for(self)
-          port_path_or_id = NewRelic::Agent::Instrumentation::Redis.port_path_or_id_for(self)
-  
-          segment = NewRelic::Agent::Tracer.start_datastore_segment(
-            product: NewRelic::Agent::Datastores::Redis::PRODUCT_NAME,
-            operation: operation,
-            host: hostname,
-            port_path_or_id: port_path_or_id,
-            database_name: db
-          )
-          begin
-            segment.notice_nosql_statement(statement) if statement
-            NewRelic::Agent::Tracer.capture_segment_error segment do
-              call_without_new_relic(*args, **kwargs, &block)
-            end
-          ensure
-            segment.finish if segment
+      def call(*args, &block)
+        operation = args[0][0]
+        statement = ::NewRelic::Agent::Datastores::Redis.format_command(args[0])
+
+        hostname = NewRelic::Agent::Instrumentation::Redis.host_for(self)
+        port_path_or_id = NewRelic::Agent::Instrumentation::Redis.port_path_or_id_for(self)
+
+        segment = NewRelic::Agent::Tracer.start_datastore_segment(
+          product: NewRelic::Agent::Datastores::Redis::PRODUCT_NAME,
+          operation: operation,
+          host: hostname,
+          port_path_or_id: port_path_or_id,
+          database_name: db
+        )
+        begin
+          segment.notice_nosql_statement(statement) if statement
+          NewRelic::Agent::Tracer.capture_segment_error segment do
+            call_without_new_relic(*args, &block)
           end
+        ensure
+          segment.finish if segment
         end
       end
-
-
-
+  
       alias_method :call_pipeline_without_new_relic, :call_pipeline
 
-      if RUBY_VERSION < "2.7.0"
-        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)
-  
-          hostname = NewRelic::Agent::Instrumentation::Redis.host_for(self)
-          port_path_or_id = NewRelic::Agent::Instrumentation::Redis.port_path_or_id_for(self)
-  
-          segment = NewRelic::Agent::Tracer.start_datastore_segment(
-            product: NewRelic::Agent::Datastores::Redis::PRODUCT_NAME,
-            operation: operation,
-            host: hostname,
-            port_path_or_id: port_path_or_id,
-            database_name: db
-          )
-          begin
-            segment.notice_nosql_statement(statement)
-            NewRelic::Agent::Tracer.capture_segment_error segment do
-              call_pipeline_without_new_relic(*args, &block)
-            end
-          ensure
-            segment.finish if segment
-          end
-        end
-      else
-        def call_pipeline(*args, **kwargs, &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)
-  
-          hostname = NewRelic::Agent::Instrumentation::Redis.host_for(self)
-          port_path_or_id = NewRelic::Agent::Instrumentation::Redis.port_path_or_id_for(self)
-  
-          segment = NewRelic::Agent::Tracer.start_datastore_segment(
-            product: NewRelic::Agent::Datastores::Redis::PRODUCT_NAME,
-            operation: operation,
-            host: hostname,
-            port_path_or_id: port_path_or_id,
-            database_name: db
-          )
-          begin
-            segment.notice_nosql_statement(statement)
-            NewRelic::Agent::Tracer.capture_segment_error segment do
-              call_pipeline_without_new_relic(*args, **kwargs, &block)
-            end
-          ensure
-            segment.finish if segment
+      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)
+
+        hostname = NewRelic::Agent::Instrumentation::Redis.host_for(self)
+        port_path_or_id = NewRelic::Agent::Instrumentation::Redis.port_path_or_id_for(self)
+
+        segment = NewRelic::Agent::Tracer.start_datastore_segment(
+          product: NewRelic::Agent::Datastores::Redis::PRODUCT_NAME,
+          operation: operation,
+          host: hostname,
+          port_path_or_id: port_path_or_id,
+          database_name: db
+        )
+        begin
+          segment.notice_nosql_statement(statement)
+          NewRelic::Agent::Tracer.capture_segment_error segment do
+            call_pipeline_without_new_relic(*args, &block)
           end
+        ensure
+          segment.finish if segment
         end
       end
 
       alias_method :connect_without_new_relic, :connect
 
-      if RUBY_VERSION < "2.7.0"
-        def connect(*args, &block)
-          hostname = NewRelic::Agent::Instrumentation::Redis.host_for(self)
-          port_path_or_id = NewRelic::Agent::Instrumentation::Redis.port_path_or_id_for(self)
-  
-          segment = NewRelic::Agent::Tracer.start_datastore_segment(
-            product: NewRelic::Agent::Datastores::Redis::PRODUCT_NAME,
-            operation: NewRelic::Agent::Datastores::Redis::CONNECT,
-            host: hostname,
-            port_path_or_id: port_path_or_id,
-            database_name: db
-          )
-  
-          begin
-            NewRelic::Agent::Tracer.capture_segment_error segment do
-              connect_without_new_relic(*args, &block)
-            end
-          ensure
-            segment.finish if segment
-          end
-        end
-      else
-        def connect(*args, **kwargs, &block)
-          hostname = NewRelic::Agent::Instrumentation::Redis.host_for(self)
-          port_path_or_id = NewRelic::Agent::Instrumentation::Redis.port_path_or_id_for(self)
-  
-          segment = NewRelic::Agent::Tracer.start_datastore_segment(
-            product: NewRelic::Agent::Datastores::Redis::PRODUCT_NAME,
-            operation: NewRelic::Agent::Datastores::Redis::CONNECT,
-            host: hostname,
-            port_path_or_id: port_path_or_id,
-            database_name: db
-          )
-  
-          begin
-            NewRelic::Agent::Tracer.capture_segment_error segment do
-              connect_without_new_relic(*args, **kwargs, &block)
-            end
-          ensure
-            segment.finish if segment
+      def connect(*args, &block)
+        hostname = NewRelic::Agent::Instrumentation::Redis.host_for(self)
+        port_path_or_id = NewRelic::Agent::Instrumentation::Redis.port_path_or_id_for(self)
+
+        segment = NewRelic::Agent::Tracer.start_datastore_segment(
+          product: NewRelic::Agent::Datastores::Redis::PRODUCT_NAME,
+          operation: NewRelic::Agent::Datastores::Redis::CONNECT,
+          host: hostname,
+          port_path_or_id: port_path_or_id,
+          database_name: db
+        )
+
+        begin
+          NewRelic::Agent::Tracer.capture_segment_error segment do
+            connect_without_new_relic(*args, &block)
           end
+        ensure
+          segment.finish if segment
         end
       end
-
     end
   end
 end

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

@@ -46,7 +46,7 @@ DependencyDetection.defer do
       end
       class Client
         def call(_worker_class, job, *_)
-          job[NewRelic::NEWRELIC_KEY] = distributed_tracing_headers if ::NewRelic::Agent.config[:'distributed_tracing.enabled']
+          job[NewRelic::NEWRELIC_KEY] ||= distributed_tracing_headers if ::NewRelic::Agent.config[:'distributed_tracing.enabled']
           yield
         end
 

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

@@ -92,24 +92,13 @@ module NewRelic
             middlewares
           end
 
-          if RUBY_VERSION < "2.7.0"
-            def build_with_newrelic(*args, &block)
-              unless NewRelic::Agent.config[:disable_sinatra_auto_middleware]
-                newrelic_middlewares.each do |middleware_class|
-                  try_to_use(self, middleware_class)
-                end
+          def build_with_newrelic(*args, &block)
+            unless NewRelic::Agent.config[:disable_sinatra_auto_middleware]
+              newrelic_middlewares.each do |middleware_class|
+                try_to_use(self, middleware_class)
               end
-              build_without_newrelic(*args, &block)
-            end
-          else 
-            def build_with_newrelic(*args, **kwargs, &block)
-              unless NewRelic::Agent.config[:disable_sinatra_auto_middleware]
-                newrelic_middlewares.each do |middleware_class|
-                  try_to_use(self, middleware_class)
-                end
-              end
-              build_without_newrelic(*args, **kwargs, &block)
             end
+            build_without_newrelic(*args, &block)
           end
 
           def try_to_use(app, clazz)
@@ -119,26 +108,14 @@ module NewRelic
         end
 
         # Capture last route we've seen. Will set for transaction on route_eval
-        if RUBY_VERSION < "2.7.0"
-          def process_route_with_newrelic(*args, &block)
-            begin
-              env["newrelic.last_route"] = args[0]
-            rescue => e
-              ::NewRelic::Agent.logger.debug("Failed determining last route in Sinatra", e)
-            end
-  
-            process_route_without_newrelic(*args, &block)
-          end
-        else 
-          def process_route_with_newrelic(*args, **kwargs, &block)
-            begin
-              env["newrelic.last_route"] = args[0]
-            rescue => e
-              ::NewRelic::Agent.logger.debug("Failed determining last route in Sinatra", e)
-            end
-  
-            process_route_without_newrelic(*args, **kwargs, &block)
+        def process_route_with_newrelic(*args, &block)
+          begin
+            env["newrelic.last_route"] = args[0]
+          rescue => e
+            ::NewRelic::Agent.logger.debug("Failed determining last route in Sinatra", e)
           end
+
+          process_route_without_newrelic(*args, &block)
         end
 
         # If a transaction name is already set, this call will tromple over it.
@@ -147,34 +124,18 @@ module NewRelic
         #
         # If we're ignored, this remains safe, since set_transaction_name
         # care for the gating on the transaction's existence for us.
-        if RUBY_VERSION < "2.7.0"
-          def route_eval_with_newrelic(*args, &block)
-            begin
-              txn_name = 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 route_eval to set transaction name", e)
-            end
-  
-            route_eval_without_newrelic(*args, &block)
-          end
-        else
-          def route_eval_with_newrelic(*args, **kwargs, &block)
-            begin
-              txn_name = 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 route_eval to set transaction name", e)
+        def route_eval_with_newrelic(*args, &block)
+          begin
+            txn_name = 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
-  
-            route_eval_without_newrelic(*args, **kwargs, &block)
+          rescue => e
+            ::NewRelic::Agent.logger.debug("Failed during route_eval to set transaction name", e)
           end
+
+          route_eval_without_newrelic(*args, &block)
         end
 
         def dispatch_with_newrelic #THREAD_LOCAL_ACCESS
@@ -220,7 +181,6 @@ module NewRelic
         def ignore_enduser?
           Ignorer.should_ignore?(self, :enduser)
         end
-
       end
     end
   end

data/lib/new_relic/agent/span_event_primitive.rb

@@ -165,16 +165,18 @@ module NewRelic
         end
       end
 
+      def merge_and_freeze_attributes agent_attributes, error_attributes
+        return agent_attributes.freeze unless error_attributes
+        return error_attributes.freeze if agent_attributes.equal?(NewRelic::EMPTY_HASH)
+        agent_attributes.merge!(error_attributes).freeze
+      end
+
       def agent_attributes segment
-        attributes = segment.attributes
-        agent_attributes = attributes.agent_attributes_for(NewRelic::Agent::AttributeFilter::DST_SPAN_EVENTS)
+        agent_attributes = segment.attributes
+          .agent_attributes_for(NewRelic::Agent::AttributeFilter::DST_SPAN_EVENTS)
         error_attributes = error_attributes(segment)
-        if agent_attributes || error_attributes
-          agent_attributes.merge!(error_attributes) if error_attributes
-          agent_attributes.freeze
-        else
-          NewRelic::EMPTY_HASH
-        end
+        return NewRelic::EMPTY_HASH unless agent_attributes || error_attributes
+        merge_and_freeze_attributes(agent_attributes, error_attributes)
       end
 
       def parent_guid segment

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

@@ -167,7 +167,7 @@ module NewRelic
 
           if finished?
             transaction.async = true
-            parent.descendant_complete self, segment
+            parent.descendant_complete(self, segment) if parent
           end
         end
 

data/lib/new_relic/agent/vm/mri_vm.rb

@@ -45,9 +45,11 @@ module NewRelic
 
         def gather_ruby_vm_stats(snap)
           if supports?(:method_cache_invalidations)
-            vm_stats = RubyVM.stat
-            snap.method_cache_invalidations = vm_stats[:global_method_state]
-            snap.constant_cache_invalidations = vm_stats[:global_constant_state]
+            snap.method_cache_invalidations = RubyVM.stat[:global_method_state]
+          end
+
+          if supports?(:constant_cache_invalidations)
+            snap.constant_cache_invalidations = RubyVM.stat[:global_constant_state]
           end
         end
 
@@ -66,7 +68,7 @@ module NewRelic
           when :minor_gc_count
             RUBY_VERSION >= '2.1.0'
           when :method_cache_invalidations
-            RUBY_VERSION >= '2.1.0'
+            RUBY_VERSION >= '2.1.0' && RUBY_VERSION < '3.0.0'
           when :constant_cache_invalidations
             RUBY_VERSION >= '2.1.0'
           else

data/lib/new_relic/cli/commands/deployments.rb

@@ -7,7 +7,6 @@
 
 require 'yaml'
 require 'net/http'
-require 'rexml/document'
 require 'new_relic/agent/hostname'
 
 # We need to use the Control object but we don't want to load

data/lib/new_relic/dependency_detection.rb

@@ -67,6 +67,10 @@ module DependencyDetection
       !executed and check_dependencies
     end
 
+    def source_location_for klass, method_name
+      Object.instance_method(:method).bind(klass.allocate).call(method_name).source_location.to_s
+    end
+  
     def execute
       @executes.each do |x|
         begin

data/lib/new_relic/environment_report.rb

@@ -69,19 +69,7 @@ module NewRelic
     report_on('Arch'              ) { ::NewRelic::Agent::SystemInfo.processor_arch         }
     report_on('OS version'        ) { ::NewRelic::Agent::SystemInfo.os_version             }
     report_on('OS'                ) { ::NewRelic::Agent::SystemInfo.ruby_os_identifier     }
-    report_on('Database adapter'  ) do
-      begin
-        if ::ActiveRecord::Base.respond_to?(:connection_db_config)
-          ActiveRecord::Base.configurations.configs_for(env_name: NewRelic::Control.instance.env, name: "primary")
-            .connection_db_config.configuration_hash['adapter']
-        else
-          ActiveRecord::Base.configurations.configs_for(env_name: NewRelic::Control.instance.env, spec_name: "primary").config['adapter']
-        end
-
-      rescue NoMethodError
-        ActiveRecord::Base.configurations[NewRelic::Control.instance.env]['adapter']
-      end
-    end
+    report_on('Database adapter'  ) { ::NewRelic::Agent::DatabaseAdapter.value }
     report_on('Framework'       ) { Agent.config[:framework].to_s  }
     report_on('Dispatcher'      ) { Agent.config[:dispatcher].to_s }
     report_on('Environment'     ) { NewRelic::Control.instance.env }

data/lib/new_relic/supportability_helper.rb

@@ -11,6 +11,7 @@ module NewRelic
     # transaction, just to eke out a bit less performance hit
     #
     API_SUPPORTABILITY_METRICS = [
+      :insert_distributed_trace_headers,
       :accept_distributed_trace_headers,
       :create_distributed_trace_headers,
       :add_custom_attributes,