newrelic_rpm 3.15.2.317 → 3.16.0.318

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3e8eefedf383e69a41a5dfb8f9c607a8c93f3390
-  data.tar.gz: 4aa588cdb66a876439bc666ab40a5dd8bb829a50
+  metadata.gz: 65e448cfa30a9ec08c2cafdeef4b85d91a4ab36b
+  data.tar.gz: 6ce77fbb0850fdd68d403672df4544c81c1c1937
 SHA512:
-  metadata.gz: aa28051c2fe6daef0a6adbbb71cb884da9ecb83ec26835ad6e5de7ddbbfd43180bdd220669ca226dbba226668b7f9e1c56274ecc01e0fe3dd9af7a0db901f9da
-  data.tar.gz: 6e9e0e4b9183378f59fab486acf5ca1eeae547f0850f6657ba50cf3df7122a9a665bfb5ce4207439c345775286516ac7c48baf3958a9182715cbe68c6ff490a4
+  metadata.gz: e5b765cb31305ef2f4e1faffe2f715a8a89c39320d21baa7d375f8c4c88d7fabd8d104b8933727ca4750fd51080d92d9c0ee361486fe40ba5e3900602137efc4
+  data.tar.gz: 6722c3012daab68738f96f5237bdbb72a18f972ba799b5e8046179d9a42f9dfbfed8e67c8382cf22e4a923748cc547de15134bef2f1c93984ad7c2569fef081c

data/CHANGELOG

@@ -1,5 +1,28 @@
 # New Relic Ruby Agent Release Notes #
 
+## v3.16.0
+
+  * Experimental Action Cable instrumentation
+
+  The Ruby agent instruments Action Cable channel actions and calls to
+  ActionCable::Channel#Transmit in Rails 5 RC1. Feedback is welcome!
+
+  * Obfuscate queries from `oracle_enhanced` adapter correctly
+
+  This change allows the `oracle_enhanced` adapter to use the same
+  obfuscation as `oracle` adapters. Thanks Dan Drinkard for the contribution!
+
+  * Make it possible to define a newrelic_role for deployment with Capistrano 3
+
+  Thanks NielsKSchjoedt for the contribution!
+
+  * Retry initial connection to New Relic in Resque master if needed
+
+  Previously, if the initial connection to New Relic in a monitored Resque
+  master process failed, the agent would not retry, and monitoring for the
+  process would be lost. This has been fixed, and the agent will continue
+  retrying in its background harvest thread until it successfully connects.
+
 ## v3.15.2 ##
 
   * Run explain plans on parameterized slow queries in AR4

data/lib/new_relic/agent.rb

@@ -286,9 +286,6 @@ module NewRelic
     #
     def manual_start(options={})
       raise "Options must be a hash" unless Hash === options
-      if options[:start_channel_listener]
-        NewRelic::Agent::PipeChannelManager.listener.start
-      end
       NewRelic::Control.instance.init_plugin({ :agent_enabled => true, :sync_startup => true }.merge(options))
     end
 

data/lib/new_relic/agent/agent.rb

@@ -730,8 +730,8 @@ module NewRelic
           # number of attempts we've made to contact the server
           attr_accessor :connect_attempts
 
-          # Disconnect just sets connected to false, which prevents
-          # the agent from trying to connect again
+          # Disconnect just sets the connect state to disconnected, preventing
+          # further retries.
           def disconnect
             @connect_state = :disconnected
             true
@@ -818,24 +818,19 @@ module NewRelic
           def connect_settings
             sanitize_environment_report
 
-            settings = {
-              :pid => $$,
-              :host => local_host,
-              :display_host => Agent.config[:'process_host.display_name'],
-              :app_name => Agent.config.app_names,
-              :language => 'ruby',
-              :labels => Agent.config.parsed_labels,
+            {
+              :pid           => $$,
+              :host          => local_host,
+              :display_host  => Agent.config[:'process_host.display_name'],
+              :app_name      => Agent.config.app_names,
+              :language      => 'ruby',
+              :labels        => Agent.config.parsed_labels,
               :agent_version => NewRelic::VERSION::STRING,
-              :environment => @environment_report,
-              :settings => Agent.config.to_collector_hash,
-              :high_security => Agent.config[:high_security]
+              :environment   => @environment_report,
+              :settings      => Agent.config.to_collector_hash,
+              :high_security => Agent.config[:high_security],
+              :utilization   => UtilizationData.new.to_collector_hash
             }
-
-            unless Agent.config[:disable_utilization]
-              settings[:utilization] = UtilizationData.new.to_collector_hash
-            end
-
-            settings
           end
 
           # Returns connect data passed back from the server
@@ -952,22 +947,24 @@ module NewRelic
 
         public :merge_data_for_endpoint
 
-        # Connect to the server and validate the license.  If successful,
-        # connected? returns true when finished.  If not successful, you can
-        # keep calling this.  Return false if we could not establish a
-        # connection with the server and we should not retry, such as if
-        # there's a bad license key.
+        # Establish a connection to New Relic servers.
+        #
+        # By default, if a connection has already been established, this method
+        # will be a no-op.
         #
-        # Set keep_retrying=false to disable retrying and return asap, such as when
-        # invoked in the foreground.  Otherwise this runs until a successful
-        # connection is made, or the server rejects us.
+        # @param [Hash] options
+        # @option options [Boolean] :keep_retrying (true)
+        #   If true, this method will block until a connection is successfully
+        #   established, continuing to retry upon failure. If false, this method
+        #   will return after either successfully connecting, or after failing
+        #   once.
+        #
+        # @option options [Boolean] :force_reconnect (false)
+        #   If true, this method will force establishment of a new connection
+        #   with New Relic, even if there is already an existing connection.
+        #   This is useful primarily when re-establishing a new connection after
+        #   forking off from a parent process.
         #
-        # * <tt>:keep_retrying => false</tt> to only try to connect once, and
-        #   return with the connection set to nil.  This ensures we may try again
-        #   later (default true).
-        # * <tt>force_reconnect => true</tt> if you want to establish a new connection
-        #   to the server before running the worker loop.  This means you get a separate
-        #   agent run and New Relic sees it as a separate instance (default is false).
         def connect(options={})
           defaults = {
             :keep_retrying => Agent.config[:keep_retrying],
@@ -995,8 +992,6 @@ module NewRelic
             ::NewRelic::Agent.logger.info "Will re-attempt in #{connect_retry_period} seconds"
             sleep connect_retry_period
             retry
-          else
-            disconnect
           end
         rescue Exception => e
           ::NewRelic::Agent.logger.error "Exception of unexpected type during Agent#connect():", e

data/lib/new_relic/agent/attribute_filter.rb

@@ -101,6 +101,8 @@ module NewRelic
         build_rule(config[:'transaction_events.attributes.include'], DST_TRANSACTION_EVENTS, true)
         build_rule(config[:'error_collector.attributes.include'],    DST_ERROR_COLLECTOR,    true)
         build_rule(config[:'browser_monitoring.attributes.include'], DST_BROWSER_MONITORING, true)
+        # This agent attribute has unexpected behaviors and we need to ensure it only goes where directed in configuration
+        build_rule(['request_uri'], DST_TRANSACTION_TRACER | DST_ERROR_COLLECTOR, false)
 
         @rules.sort!
 

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

@@ -515,6 +515,27 @@ module NewRelic
           :allowed_from_server => true,
           :description => 'Maximum number of bytes to send to the New Relic data collection service.'
         },
+        :put_for_data_send => {
+          :default => false,
+          :public => false,
+          :type => Boolean,
+          :allowed_from_server => false,
+          :description => 'Use HTTP PUT requests instead of POST.'
+        },
+        :compressed_content_encoding => {
+          :default => 'deflate',
+          :public => false,
+          :type => String,
+          :allowed_from_server => false,
+          :description => 'Encoding to use if data needs to be compressed. The options are deflate and gzip.'
+        },
+        :simple_compression => {
+          :default => false,
+          :public => false,
+          :type => Boolean,
+          :allowed_from_server => false,
+          :description => 'When enabled the agent will compress payloads destined for the collector, but will not pre-compress parts of the payload.'
+        },
         :timeout => {
           :default => 2 * 60, # 2 minutes
           :public => true,
@@ -694,6 +715,14 @@ module NewRelic
           :allowed_from_server => false,
           :description => 'If <code>true</code>, disables ActiveJob instrumentation.'
         },
+        :disable_action_cable_instrumentation => {
+          :default => false,
+          :public => true,
+          :type => Boolean,
+          :dynamic_name => true,
+          :allowed_from_server => false,
+          :description => 'If <code>true</code>, disables Action Cable instrumentation.'
+        },
         :disable_memcached => {
           :default => value_of(:disable_memcache_instrumentation),
           :public => true,
@@ -1542,12 +1571,29 @@ module NewRelic
           :allowed_from_server => false,
           :description => 'If <code>true</code>, the agent automatically detects that it is running in Docker.'
         },
-        :'disable_utilization' => {
-          :default     => false,
+        :'utilization.billing_hostname' => {
+          :default     => nil,
+          :allow_nil   => true,
           :public      => false,
-          :type        => Boolean,
+          :type        => String,
+          :allowed_from_server => false,
+          :description => 'The configured server name by a customer.'
+        },
+        :'utilization.logical_processors' => {
+          :default     => nil,
+          :allow_nil   => true,
+          :public      => false,
+          :type        => Fixnum,
+          :allowed_from_server => false,
+          :description => 'The total number of hyper-threaded execution contexts available.'
+        },
+        :'utilization.total_ram_mib' => {
+          :default     => nil,
+          :allow_nil   => true,
+          :public      => false,
+          :type        => Fixnum,
           :allowed_from_server => false,
-          :description => 'Disable sending utilization data as part of connect settings hash.'
+          :description => 'This value represents the total amount of memory available to the host (not the process), in mebibytes (1024 squared or 1,048,576 bytes).'
         }
       }.freeze
     end

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

@@ -44,7 +44,8 @@ module NewRelic
           :postgres => /'|\/\*|\*\/|\$(?!\?)/,
           :sqlite => /'|\/\*|\*\//,
           :cassandra => /'|\/\*|\*\//,
-          :oracle => /'|\/\*|\*\//
+          :oracle => /'|\/\*|\*\//,
+          :oracle_enhanced => /'|\/\*|\*\//
         }
 
         PLACEHOLDER = '?'.freeze
@@ -75,7 +76,7 @@ module NewRelic
             regex = POSTGRES_COMPONENTS_REGEX
           when :sqlite
             regex = SQLITE_COMPONENTS_REGEX
-          when :oracle
+          when :oracle, :oracle_enhanced
             regex = ORACLE_COMPONENTS_REGEX
           when :cassandra
             regex = CASSANDRA_COMPONENTS_REGEX

data/lib/new_relic/agent/hash_extensions.rb

@@ -21,6 +21,21 @@ module NewRelic
           object
         end
       end
+
+       # recurses through hashes and arrays and symbolizes keys
+      def symbolize_keys_in_object(object)
+        case object
+        when Hash
+          object.inject({}) do |memo, (k, v)|
+            memo[k.to_sym] = symbolize_keys_in_object(v)
+            memo
+          end
+        when Array
+          object.map {|o| symbolize_keys_in_object(o)}
+        else
+          object
+        end
+      end
     end
   end
-end
+end

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

@@ -0,0 +1,82 @@
+# 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/instrumentation/evented_subscriber'
+
+module NewRelic
+  module Agent
+    module Instrumentation
+      class ActionCableSubscriber < EventedSubscriber
+
+        PERFORM_ACTION = 'perform_action.action_cable'.freeze
+
+        def start name, id, payload #THREAD_LOCAL_ACCESS
+          state = NewRelic::Agent::TransactionState.tl_get
+          return unless state.is_execution_traced?
+          event = super
+          if event.name == PERFORM_ACTION
+            start_transaction state, event
+          else
+            start_recording_metrics state, event
+          end
+        rescue => e
+          log_notification_error e, name, 'start'
+        end
+
+        def finish name, id, payload #THREAD_LOCAL_ACCESS
+          state = NewRelic::Agent::TransactionState.tl_get
+          return unless state.is_execution_traced?
+          event = super
+          notice_error payload if payload.key? :exception
+          if event.name == PERFORM_ACTION
+            finish_transaction state
+          else
+            stop_recording_metrics state, event
+          end
+        rescue => e
+          log_notification_error e, name, 'finish'
+        end
+
+        private
+
+        def start_transaction state, event
+          Transaction.start(state, :action_cable, :transaction_name => transaction_name_from_event(event))
+        end
+
+        def finish_transaction state
+          Transaction.stop(state)
+        end
+
+        def start_recording_metrics state, event
+          expected_scope = MethodTracerHelpers::trace_execution_scoped_header(state, event.time.to_f)
+          event.payload[:expected_scope] =  expected_scope
+        end
+
+        def stop_recording_metrics state, event
+          expected_scope = event.payload.delete :expected_scope
+          metric_name = metric_name_from_event event
+          MethodTracerHelpers::trace_execution_scoped_footer(state, event.time.to_f, metric_name, [], expected_scope, {:metric => true}, event.end.to_f)
+        end
+
+        def transaction_name_from_event event
+          "Controller/ActionCable/#{event.payload[:channel_class]}/#{event.payload[:action]}"
+        end
+
+        def metric_name_from_event event
+          "Ruby/ActionCable/#{event.payload[:channel_class]}/#{action_name_from_event(event)}"
+        end
+
+        DOT_ACTION_CABLE = ".action_cable".freeze
+        EMPTY_STRING = "".freeze
+
+        def action_name_from_event event
+          event.name.gsub DOT_ACTION_CABLE, EMPTY_STRING
+        end
+
+        def notice_error payload
+          NewRelic::Agent.notice_error payload[:exception_object]
+        end
+      end
+    end
+  end
+end

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

@@ -228,14 +228,15 @@ module NewRelic
           def self.prefix_for_category(txn, category = nil)
             category ||= (txn && txn.category)
             case category
-            when :controller then ::NewRelic::Agent::Transaction::CONTROLLER_PREFIX
-            when :task       then ::NewRelic::Agent::Transaction::TASK_PREFIX
-            when :rack       then ::NewRelic::Agent::Transaction::RACK_PREFIX
-            when :uri        then ::NewRelic::Agent::Transaction::CONTROLLER_PREFIX
-            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
+            when :controller    then ::NewRelic::Agent::Transaction::CONTROLLER_PREFIX
+            when :task          then ::NewRelic::Agent::Transaction::TASK_PREFIX
+            when :rack          then ::NewRelic::Agent::Transaction::RACK_PREFIX
+            when :uri           then ::NewRelic::Agent::Transaction::CONTROLLER_PREFIX
+            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
+            when :action_cable  then ::NewRelic::Agent::Transaction::ACTION_CABLE_PREFIX
             else "#{category.to_s}/" # for internal use only
             end
           end

data/lib/new_relic/agent/instrumentation/rails5/action_cable.rb

@@ -0,0 +1,29 @@
+# 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/instrumentation/action_cable_subscriber'
+
+DependencyDetection.defer do
+  @name = :rails5_action_cable
+
+  depends_on do
+    defined?(::Rails) &&
+     ::Rails::VERSION::MAJOR.to_i == 5 &&
+       defined?(::ActionCable)
+  end
+
+  depends_on do
+    !NewRelic::Agent.config[:disable_action_cable_instrumentation] &&
+      !NewRelic::Agent::Instrumentation::ActionCableSubscriber.subscribed?
+  end
+
+  executes do
+    ::NewRelic::Agent.logger.info 'Installing Rails 5 Action Cable instrumentation'
+  end
+
+  executes do
+    # enumerate the specific events we want so that we do not get unexpected additions in the future
+    ActiveSupport::Notifications.subscribe(/(perform_action|transmit)\.action_cable/,
+      NewRelic::Agent::Instrumentation::ActionCableSubscriber.new)
+  end
+end

data/lib/new_relic/agent/new_relic_service.rb

@@ -164,8 +164,12 @@ module NewRelic
       def compress_request_if_needed(data)
         encoding = 'identity'
         if data.size > 64 * 1024
-          data = Encoders::Compressed.encode(data)
-          encoding = 'deflate'
+          encoding = Agent.config[:compressed_content_encoding]
+          data = if encoding == 'gzip'
+            Encoders::Compressed::Gzip.encode(data)
+          else
+            Encoders::Compressed::Deflate.encode(data)
+          end
         end
         check_post_size(data)
         [data, encoding]
@@ -432,7 +436,11 @@ module NewRelic
       #                    contact
       #  - :data => the data to send as the body of the request
       def send_request(opts)
-        request = Net::HTTP::Post.new(opts[:uri], 'CONTENT-ENCODING' => opts[:encoding], 'HOST' => opts[:collector].name)
+        if Agent.config[:put_for_data_send]
+          request = Net::HTTP::Put.new(opts[:uri], 'CONTENT-ENCODING' => opts[:encoding], 'HOST' => opts[:collector].name)
+        else
+          request = Net::HTTP::Post.new(opts[:uri], 'CONTENT-ENCODING' => opts[:encoding], 'HOST' => opts[:collector].name)
+        end
         request['user-agent'] = user_agent
         request.content_type = "application/octet-stream"
         request.body = opts[:data]
@@ -444,7 +452,7 @@ module NewRelic
         begin
           attempts += 1
           conn = http_connection
-          ::NewRelic::Agent.logger.debug "Sending request to #{opts[:collector]}#{opts[:uri]}"
+          ::NewRelic::Agent.logger.debug "Sending request to #{opts[:collector]}#{opts[:uri]} with #{request.method}"
           NewRelic::TimerLib.timeout(@request_timeout) do
             response = conn.request(request)
           end