newrelic_rpm 3.8.1.221 → 3.9.0.229

data/lib/new_relic/rack/error_collector.rb

@@ -2,7 +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/rack/transaction_reset'
+require 'new_relic/rack/agent_middleware'
+require 'new_relic/agent/instrumentation/middleware_proxy'
 
 module NewRelic::Rack
   # This middleware is used by the agent in order to capture exceptions that
@@ -12,13 +13,7 @@ module NewRelic::Rack
   #
   # @api public
   #
-  class ErrorCollector
-    def initialize(app, options={})
-      @app = app
-    end
-
-    include TransactionReset
-
+  class ErrorCollector < AgentMiddleware
     def params_from_env(env)
       if defined?(ActionDispatch::Request)
         # We use ActionDispatch::Request if it's available so that we can get
@@ -50,56 +45,23 @@ module NewRelic::Rack
       strip_query_string(env['HTTP_REFERER'].to_s)
     end
 
-    def call(env)
-      ensure_transaction_reset(env)
-      @app.call(env)
-    rescue Exception => exception
-      NewRelic::Agent.logger.debug "collecting %p: %s" % [ exception.class, exception.message ]
-      if !should_ignore_error?(exception, env)
-        NewRelic::Agent.notice_error(exception,
-                                     :uri => uri_from_env(env),
-                                     :referer => referrer_from_env(env),
-                                     :request_params => params_from_env(env))
-      end
-      raise exception
-    end
-
-    def should_ignore_error?(error, env)
-      NewRelic::Agent.instance.error_collector.error_is_ignored?(error) ||
-        ignored_in_controller?(error, env)
-    end
-
-    def ignored_in_controller?(exception, env)
-      return true if env['newrelic.ignored']
-
-      if env['action_dispatch.request.parameters']
-        ignore_actions = newrelic_ignore_for_controller(env['action_dispatch.request.parameters']['controller'])
-        action_name = env['action_dispatch.request.parameters']['action']
-
-        case ignore_actions
-        when nil; false
-        when Hash
-          only_actions = Array(ignore_actions[:only])
-          except_actions = Array(ignore_actions[:except])
-          only_actions.include?(action_name.to_sym) ||
-            (except_actions.any? &&
-             !except_actions.include?(action_name.to_sym))
-        else
-          true
+    def traced_call(env)
+      begin
+        @app.call(env)
+      rescue Exception => exception
+        NewRelic::Agent.logger.debug "collecting %p: %s" % [ exception.class, exception.message ]
+        if !should_ignore_error?(exception, env)
+          NewRelic::Agent.notice_error(exception,
+                                       :uri => uri_from_env(env),
+                                       :referer => referrer_from_env(env),
+                                       :request_params => params_from_env(env))
         end
+        raise exception
       end
     end
 
-    def newrelic_ignore_for_controller(controller_name)
-      if controller_name
-        controller_constant_name = (controller_name + "_controller").camelize
-        if Object.const_defined?(controller_constant_name)
-          controller = controller_constant_name.constantize
-          controller.instance_variable_get(:@do_not_trace)
-        end
-      end
-    rescue NameError
-      nil
+    def should_ignore_error?(error, env)
+      NewRelic::Agent.instance.error_collector.error_is_ignored?(error)
     end
   end
 end

data/lib/new_relic/recipes.rb

@@ -2,116 +2,23 @@
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
 
-# When installed as a plugin this is loaded automatically.
+# When installed as a plugin, this is loaded automatically.
 #
 # When installed as a gem, you need to add
 #  require 'new_relic/recipes'
-# to your deploy.rb
+# to deploy.rb
 #
-# Defined deploy:notify_rpm which will send information about the deploy to New Relic.
-# The task will run on app servers except where no_release is true.
-# If it fails, it will not affect the task execution or do a rollback.
+# Defines newrelic:notice_deployment, which sends information about the deploy
+# to New Relic. The task will run on all app release roles. If it fails, it will
+# not affect the execution of subsequent tasks or cause a rollback.
 #
 # @api public
 #
-make_notify_task = Proc.new do
-
-  namespace :newrelic do
-
-    # on all deployments, notify New Relic
-    desc "Record a deployment in New Relic (newrelic.com)"
-    task :notice_deployment, :roles => :app, :except => {:no_release => true } do
-      rails_env = fetch(:newrelic_rails_env, fetch(:rails_env, "production"))
-
-      require File.join(File.dirname(__FILE__), 'cli', 'command.rb')
-
-      begin
-        # allow overrides to be defined for revision, description, changelog, appname, and user
-        rev         = fetch(:newrelic_revision)    if exists?(:newrelic_revision)
-        description = fetch(:newrelic_desc)        if exists?(:newrelic_desc)
-        changelog   = fetch(:newrelic_changelog)   if exists?(:newrelic_changelog)
-        appname     = fetch(:newrelic_appname)     if exists?(:newrelic_appname)
-        user        = fetch(:newrelic_user)        if exists?(:newrelic_user)
-        license_key = fetch(:newrelic_license_key) if exists?(:newrelic_license_key)
-
-        unless scm.to_sym == :none
-          changelog = lookup_changelog(changelog)
-          rev       = lookup_rev(rev)
-        end
-
-        new_revision = rev
-        deploy_options = {
-          :environment => rails_env,
-          :revision    => new_revision,
-          :changelog   => changelog,
-          :description => description,
-          :appname     => appname,
-          :user        => user,
-          :license_key => license_key
-        }
-
-        logger.debug "Uploading deployment to New Relic"
-        deployment = NewRelic::Cli::Deployments.new deploy_options
-        deployment.run
-        logger.info "Uploaded deployment information to New Relic"
-
-      rescue NewRelic::Cli::Command::CommandFailure => e
-        logger.info e.message
-
-      rescue Capistrano::CommandError
-        logger.info "Unable to notify New Relic of the deployment... skipping"
-
-      rescue => e
-        logger.info "Error creating New Relic deployment (#{e})\n#{e.backtrace.join("\n")}"
-      end
-
-      # WIP: For rollbacks, let's update the deployment we created with an indication of the failure:
-      # on_rollback do
-      #   run(...)
-      # end
-    end
-
-    def lookup_changelog(changelog)
-      if !changelog
-        logger.debug "Getting log of changes for New Relic Deployment details"
-        from_revision = source.next_revision(current_revision)
-
-        if scm.to_sym == :git
-          log_command = "git log --no-color --pretty=format:'  * %an: %s' " +
-            "--abbrev-commit --no-merges #{previous_revision}..#{real_revision}"
-        else
-          log_command = "#{source.log(from_revision)}"
-        end
-
-        changelog = `#{log_command}`
-      end
-      changelog
-    end
-
-    def lookup_rev(rev)
-      if rev.nil?
-        rev = source.query_revision(source.head()) do |cmd|
-          logger.debug "executing locally: '#{cmd}'"
-          `#{cmd}`
-        end
-
-        rev = rev[0..6] if scm.to_sym == :git
-      end
-      rev
-    end
-  end
-end
 
 require 'capistrano/version'
 
-if defined?(Capistrano::Version::MAJOR) && Capistrano::Version::MAJOR < 2
-  STDERR.puts "Unable to load #{__FILE__}\nNew Relic Capistrano hooks require at least version 2.0.0"
+if defined?(Capistrano::VERSION) && Capistrano::VERSION.to_s.split('.').first.to_i >= 3
+  require 'new_relic/recipes/capistrano3'
 else
-  instance = Capistrano::Configuration.instance
-
-  if instance
-    instance.load &make_notify_task
-  else
-    make_notify_task.call
-  end
+  require 'new_relic/recipes/capistrano_legacy'
 end

data/lib/new_relic/recipes/capistrano3.rb

@@ -0,0 +1,66 @@
+# 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 'capistrano/framework'
+
+namespace :newrelic do
+
+  # notifies New Relic of a deployment
+  desc "Record a deployment in New Relic (newrelic.com)"
+  task :notice_deployment do
+    on roles(:app) do
+      rails_env = fetch(:newrelic_rails_env, fetch(:rails_env, "production"))
+
+      require 'new_relic/cli/command.rb'
+
+      begin
+        # allow overrides to be defined for revision, description, changelog, appname, and user
+        rev         = fetch(:newrelic_revision)
+        description = fetch(:newrelic_desc)
+        changelog   = fetch(:newrelic_changelog)
+        appname     = fetch(:newrelic_appname)
+        user        = fetch(:newrelic_user)
+        license_key = fetch(:newrelic_license_key)
+
+        unless scm == :none
+          changelog ||= lookup_changelog
+          rev       = fetch(:current_revision)
+        end
+
+        new_revision = rev
+        deploy_options = {
+          :environment => rails_env,
+          :revision    => new_revision,
+          :changelog   => changelog,
+          :description => description,
+          :appname     => appname,
+          :user        => user,
+          :license_key => license_key
+        }
+
+        debug "Uploading deployment to New Relic"
+        deployment = NewRelic::Cli::Deployments.new deploy_options
+        deployment.run
+        info "Uploaded deployment information to New Relic"
+
+      rescue NewRelic::Cli::Command::CommandFailure => e
+        info e.message
+      rescue => e
+        info "Error creating New Relic deployment (#{e})\n#{e.backtrace.join("\n")}"
+      end
+    end
+  end
+
+  def lookup_changelog
+    debug "Retrieving changelog for New Relic Deployment details"
+    previous_revision = fetch(:previous_revision)
+    current_revision = fetch(:current_revision)
+
+    if scm == :git
+      log_command = "git log --no-color --pretty=format:'  * %an: %s' " +
+                    "--abbrev-commit --no-merges #{previous_revision}..#{current_revision}"
+      `#{log_command}`
+    end
+  end
+end

data/lib/new_relic/recipes/capistrano_legacy.rb

@@ -0,0 +1,98 @@
+# 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.
+
+make_notify_task = Proc.new do
+
+  namespace :newrelic do
+
+    # on all deployments, notify New Relic
+    desc "Record a deployment in New Relic (newrelic.com)"
+    task :notice_deployment, :roles => :app, :except => {:no_release => true } do
+      rails_env = fetch(:newrelic_rails_env, fetch(:rails_env, "production"))
+
+      require 'new_relic/cli/command'
+
+      begin
+        # allow overrides to be defined for revision, description, changelog, appname, and user
+        rev         = fetch(:newrelic_revision)    if exists?(:newrelic_revision)
+        description = fetch(:newrelic_desc)        if exists?(:newrelic_desc)
+        changelog   = fetch(:newrelic_changelog)   if exists?(:newrelic_changelog)
+        appname     = fetch(:newrelic_appname)     if exists?(:newrelic_appname)
+        user        = fetch(:newrelic_user)        if exists?(:newrelic_user)
+        license_key = fetch(:newrelic_license_key) if exists?(:newrelic_license_key)
+
+        unless scm == :none
+          changelog = lookup_changelog(changelog)
+          rev       = lookup_rev(rev)
+        end
+
+        new_revision = rev
+        deploy_options = {
+          :environment => rails_env,
+          :revision    => new_revision,
+          :changelog   => changelog,
+          :description => description,
+          :appname     => appname,
+          :user        => user,
+          :license_key => license_key
+        }
+
+        logger.debug "Uploading deployment to New Relic"
+        deployment = NewRelic::Cli::Deployments.new deploy_options
+        deployment.run
+        logger.info "Uploaded deployment information to New Relic"
+
+      rescue NewRelic::Cli::Command::CommandFailure => e
+        logger.info e.message
+      rescue Capistrano::CommandError
+        logger.info "Unable to notify New Relic of the deployment... skipping"
+      rescue => e
+        logger.info "Error creating New Relic deployment (#{e})\n#{e.backtrace.join("\n")}"
+      end
+    end
+
+    def lookup_changelog(changelog)
+      if !changelog
+        logger.debug "Getting log of changes for New Relic Deployment details"
+        from_revision = source.next_revision(current_revision)
+
+        if scm == :git
+          log_command = "git log --no-color --pretty=format:'  * %an: %s' " +
+            "--abbrev-commit --no-merges #{previous_revision}..#{real_revision}"
+        else
+          log_command = "#{source.log(from_revision)}"
+        end
+
+        changelog = `#{log_command}`
+      end
+      changelog
+    end
+
+    def lookup_rev(rev)
+      if rev.nil?
+        rev = source.query_revision(source.head()) do |cmd|
+          logger.debug "executing locally: '#{cmd}'"
+          `#{cmd}`
+        end
+
+        rev = rev[0..6] if scm == :git
+      end
+      rev
+    end
+  end
+end
+
+require 'capistrano/version'
+
+if defined?(Capistrano::Version::MAJOR) && Capistrano::Version::MAJOR < 2
+  STDERR.puts "Unable to load #{__FILE__}\nNew Relic Capistrano hooks require at least version 2.0.0"
+else
+  instance = Capistrano::Configuration.instance
+
+  if instance
+    instance.load &make_notify_task
+  else
+    make_notify_task.call
+  end
+end

data/lib/new_relic/transaction_sample.rb

@@ -101,11 +101,11 @@ module NewRelic
     end
 
     # relative_timestamp is seconds since the start of the transaction
-    def create_segment(relative_timestamp, metric_name=nil, segment_id = nil)
+    def create_segment(relative_timestamp, metric_name=nil)
       raise TypeError.new("Frozen Transaction Sample") if finished
       @params[:segment_count] += 1
       @segment_count += 1
-      NewRelic::TransactionSample::Segment.new(relative_timestamp, metric_name, segment_id)
+      NewRelic::TransactionSample::Segment.new(relative_timestamp, metric_name)
     end
 
     def duration
@@ -156,25 +156,6 @@ module NewRelic
       s <<  @root_segment.to_debug_str(0)
     end
 
-    # return a new transaction sample that treats segments
-    # with the given regular expression in their name as if they
-    # were never called at all.  This allows us to strip out segments
-    # from traces captured in development environment that would not
-    # normally show up in production (like Rails/Application Code Loading)
-    def omit_segments_with(regex)
-      regex = Regexp.new(regex)
-
-      sample = TransactionSample.new(@start_time, sample_id)
-
-      sample.params = params.dup
-      sample.params[:segment_count] = 0
-
-      delta = build_segment_with_omissions(sample, 0.0, @root_segment, sample.root_segment, regex)
-      sample.root_segment.end_trace(@root_segment.exit_timestamp - delta)
-      sample.profile = self.profile
-      sample
-    end
-
     # Return a new transaction sample that can be sent to the New
     # Relic service.
     def prepare_to_send!
@@ -195,43 +176,14 @@ module NewRelic
       @params = params
     end
 
-    def force_persist_sample?
-      NewRelic::Agent::TransactionState.get.request_token &&
-        self.duration > NewRelic::Agent::TransactionState.get.current_transaction.apdex_t
+    def force_persist_sample? #THREAD_LOCAL_ACCESS
+      state = NewRelic::Agent::TransactionState.tl_get
+
+      state.request_token && self.duration > state.current_transaction.apdex_t
     end
 
   private
 
-    # This is badly in need of refactoring
-    def build_segment_with_omissions(new_sample, time_delta, source_segment, target_segment, regex)
-      source_segment.called_segments.each do |source_called_segment|
-        # if this segment's metric name matches the given regular expression, bail
-        # here and increase the amount of time that we reduce the target sample with
-        # by this omitted segment's duration.
-        do_omit = regex =~ source_called_segment.metric_name
-
-        if do_omit
-          time_delta += source_called_segment.duration
-        else
-          target_called_segment = new_sample.create_segment(
-                source_called_segment.entry_timestamp - time_delta,
-                source_called_segment.metric_name,
-                source_called_segment.segment_id)
-
-          target_segment.add_called_segment target_called_segment
-          source_called_segment.params.each do |k,v|
-            target_called_segment[k]=v
-          end
-
-          time_delta = build_segment_with_omissions(
-                new_sample, time_delta, source_called_segment, target_called_segment, regex)
-          target_called_segment.end_trace(source_called_segment.exit_timestamp - time_delta)
-        end
-      end
-
-      return time_delta
-    end
-
     def strip_sql!
       each_segment do |segment|
         segment.params.delete(:sql)