newrelic_rpm 3.6.6.147 → 3.6.7.152

data/lib/new_relic/agent/transaction_sampler.rb

@@ -22,8 +22,6 @@ module NewRelic
         def notice_scope_empty(*args); end
       end
 
-      BUILDER_KEY = :transaction_sample_builder
-
       attr_accessor :random_sampling, :sampling_rate
       attr_accessor :slow_capture_threshold
       attr_reader :samples, :last_sample, :disabled
@@ -178,7 +176,7 @@ module NewRelic
 
         sampler_methods.each{|sym| send(sym, sample) }
 
-        if NewRelic::Agent::TransactionInfo.get.force_persist_sample?(sample)
+        if sample.force_persist_sample?
           store_force_persist(sample)
         end
       end
@@ -301,8 +299,7 @@ module NewRelic
       # Appends a backtrace to a segment if that segment took longer
       # than the specified duration
       def append_backtrace(segment, duration)
-        if (duration >= Agent.config[:'transaction_tracer.stack_trace_threshold'] ||
-            Thread.current[:capture_deep_tt])
+        if duration >= Agent.config[:'transaction_tracer.stack_trace_threshold']
           segment[:backtrace] = caller.join("\n")
         end
       end
@@ -448,19 +445,19 @@ module NewRelic
         if !enabled? || !NewRelic::Agent.is_transaction_traced? || !NewRelic::Agent.is_execution_traced?
           clear_builder
         else
-          Thread::current[BUILDER_KEY] ||= TransactionSampleBuilder.new(time)
+          TransactionState.get.transaction_sample_builder ||= TransactionSampleBuilder.new(time)
         end
       end
 
       # The current thread-local transaction sample builder
       def builder
-        Thread::current[BUILDER_KEY]
+        TransactionState.get.transaction_sample_builder
       end
 
       # Sets the thread local variable storing the transaction sample
       # builder to nil to clear it
       def clear_builder
-        Thread::current[BUILDER_KEY] = nil
+        TransactionState.get.transaction_sample_builder = nil
       end
 
     end

data/lib/new_relic/agent/transaction_state.rb

@@ -0,0 +1,166 @@
+# 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/browser_token'
+
+module NewRelic
+  module Agent
+
+    # This is THE location to store thread local information during a transaction
+    # Need a new piece of data? Add a method here, NOT a new thread local variable.
+    class TransactionState
+
+      def self.get
+        state_for(Thread.current)
+      end
+
+      # This method should only be used by TransactionState for access to the
+      # current thread's state or to provide read-only accessors for other threads
+      #
+      # If ever exposed, this requires additional synchronization
+      def self.state_for(thread)
+        thread[:newrelic_transaction_state] ||= TransactionState.new
+      end
+      private_class_method :state_for
+
+      def self.clear
+        Thread.current[:newrelic_transaction_state] = nil
+      end
+
+      # This starts the timer for the transaction.
+      def self.reset(request=nil)
+        self.get.reset(request)
+      end
+
+      def initialize
+        @stats_scope_stack = []
+      end
+
+      def reset(request)
+        # We almost always want to use the transaction time, but in case it's
+        # not available, we track the last reset. No accessor, as only the
+        # TransactionState class should use it.
+        @last_reset_time = Time.now
+
+        @transaction = Transaction.current
+        @timings = nil
+
+        @request = request
+        @request_token = BrowserToken.get_token(request)
+        @request_guid = ""
+        @request_ignore_enduser = false
+      end
+
+      def timings
+        @timings ||= TransactionTimings.new(transaction_queue_time, transaction_start_time, transaction_name)
+      end
+
+      # Cross app tracing
+      # Because we need values from headers before the transaction actually starts
+      attr_accessor :client_cross_app_id, :referring_transaction_info
+
+      # Request data
+      attr_accessor :request, :request_token, :request_guid, :request_ignore_enduser
+
+      # Current transaction stack and sample building
+      attr_accessor :transaction, :transaction_sample_builder
+      attr_writer   :current_transaction_stack
+
+      # Returns and initializes the transaction stack if necessary
+      #
+      # We don't default in the initializer so non-transaction threads retain
+      # a nil stack, and methods in this class use has_current_transction?
+      # instead of this accessor to see if we're a transaction thread or not
+      def current_transaction_stack
+        @current_transaction_stack ||= []
+      end
+
+      def transaction_start_time
+        if transaction.nil?
+          @last_reset_time
+        else
+          transaction.start_time
+        end
+      end
+
+      def transaction_queue_time
+        transaction.nil? ? 0.0 : transaction.queue_time
+      end
+
+      def transaction_name
+        transaction.nil? ? nil : transaction.name
+      end
+
+      def transaction_noticed_error_ids
+        transaction.nil? ? [] : transaction.noticed_error_ids
+      end
+
+      def self.in_background_transaction?(thread)
+        state_for(thread).in_background_transaction?
+      end
+
+      def self.in_request_transaction?(thread)
+        state_for(thread).in_request_transaction?
+      end
+
+      def in_background_transaction?
+        !current_transaction.nil? && current_transaction.request.nil?
+      end
+
+      def in_request_transaction?
+        !current_transaction.nil? && !current_transaction.request.nil?
+      end
+
+      def current_transaction
+        current_transaction_stack.last if has_current_transaction?
+      end
+
+      def has_current_transaction?
+        !@current_transaction_stack.nil?
+      end
+
+      # Execution tracing on current thread
+      attr_accessor :untraced
+
+      def push_traced(should_trace)
+        @untraced ||= []
+        @untraced << should_trace
+      end
+
+      def pop_traced
+        @untraced.pop if @untraced
+      end
+
+      def is_traced?
+        @untraced.nil? || @untraced.last != false
+      end
+
+      # TT's and SQL
+      attr_accessor :record_tt, :record_sql
+
+      def is_transaction_traced?
+        @record_tt != false
+      end
+
+      def is_sql_recorded?
+        @record_sql != false
+      end
+
+      # Busy calculator
+      attr_accessor :busy_entries
+
+      # Sql Sampler Transaction Data
+      attr_accessor :sql_sampler_transaction_data
+
+      # Scope stack tracking from NewRelic::StatsEngine::Transactions
+      # Should not be nil--this class manages its initialization and resetting
+      attr_accessor :stats_scope_stack
+
+      def clear_stats_scope_stack
+        @stats_scope_stack = []
+      end
+
+    end
+  end
+end

data/lib/new_relic/agent/transaction_timings.rb

@@ -0,0 +1,53 @@
+# 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.
+
+module NewRelic
+  module Agent
+    class TransactionTimings
+
+      def initialize(queue_time_in_seconds, start_time_in_seconds, transaction_name)
+        @now = Time.now.to_f
+        @queue_time_in_seconds = clamp_to_positive(queue_time_in_seconds.to_f)
+        @start_time_in_seconds = clamp_to_positive(start_time_in_seconds.to_f)
+
+        @transaction_name = transaction_name
+      end
+
+      attr_reader :transaction_name,
+        :start_time_in_seconds, :queue_time_in_seconds
+
+      def start_time_as_time
+        Time.at(@start_time_in_seconds)
+      end
+
+      def start_time_in_millis
+        convert_to_milliseconds(@start_time_in_seconds)
+      end
+
+      def queue_time_in_millis
+        convert_to_milliseconds(queue_time_in_seconds)
+      end
+
+      def app_time_in_millis
+        convert_to_milliseconds(app_time_in_seconds)
+      end
+
+      def app_time_in_seconds
+        @now - @start_time_in_seconds
+      end
+
+      # Helpers
+
+      def convert_to_milliseconds(value_in_seconds)
+        clamp_to_positive((value_in_seconds.to_f * 1000.0).round)
+      end
+
+      def clamp_to_positive(value)
+        return 0.0 if value < 0.0
+        value
+      end
+
+    end
+  end
+end

data/lib/new_relic/cli/command.rb

@@ -0,0 +1,91 @@
+# 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 'optparse'
+
+# Run the command given by the first argument.  Right
+# now all we have is deployments. We hope to have other
+# kinds of events here later.
+$LOAD_PATH << "#{File.dirname(__FILE__)}/.."
+module NewRelic
+  module Cli
+    class Command
+      attr_accessor :leftover
+      # Capture a failure to execute the command.
+      class CommandFailure < StandardError
+        attr_reader :options
+        def initialize message, opt_parser=nil
+          super message
+          @options = opt_parser
+        end
+      end
+
+      def info(message)
+        STDOUT.puts message
+      end
+
+      def err(message)
+        STDERR.puts message
+      end
+
+      def initialize(command_line_args)
+        if Hash === command_line_args
+          # command line args is an options hash
+          command_line_args.each do | key, value |
+            instance_variable_set "@#{key}", value.to_s if value
+          end
+        else
+          # parse command line args.  Throw an exception on a bad arg.
+          @options = options do | opts |
+            opts.on("-h", "Show this help") {  raise CommandFailure, opts.to_s }
+          end
+          @leftover = @options.parse(command_line_args)
+        end
+      rescue OptionParser::ParseError => e
+        raise CommandFailure.new(e.message, @options)
+      end
+
+      @commands = []
+      def self.inherited(subclass)
+        @commands << subclass
+      end
+
+      cmds = File.expand_path(File.join(File.dirname(__FILE__), '*.rb'))
+      Dir[cmds].each{|command| require command }
+
+      def self.run
+
+        @command_names = @commands.map{ |c| c.command }
+
+        extra = []
+        options = ARGV.options do |opts|
+          script_name = File.basename($0)
+          if script_name =~ /newrelic_cmd$/
+            $stdout.puts "warning: the 'newrelic_cmd' script has been renamed 'newrelic'"
+            script_name = 'newrelic'
+          end
+          opts.banner = "Usage: #{script_name} [ #{ @command_names.join(" | ")} ] [options]"
+          opts.separator "use '#{script_name} <command> -h' to see detailed command options"
+          opts
+        end
+        extra = options.order!
+        command = extra.shift
+        # just make it a little easier on them
+        command = 'deployments' if command =~ /deploy/
+          if command.nil?
+            STDERR.puts options
+          elsif !@command_names.include?(command)
+            STDERR.puts "Unrecognized command: #{command}"
+            STDERR.puts options
+          else
+            command_class = @commands.find{ |c| c.command == command}
+            command_class.new(extra).run
+          end
+      rescue OptionParser::InvalidOption => e
+        raise NewRelic::Cli::Command::CommandFailure, e.message
+      end
+    end
+
+  end
+end

data/lib/new_relic/{commands → cli}/deployments.rb

@@ -14,7 +14,7 @@ require 'rexml/document'
 # it won't load it twice, something it does when run inside a test
 require 'new_relic/control' unless defined? NewRelic::Control
 
-class NewRelic::Command::Deployments < NewRelic::Command
+class NewRelic::Cli::Deployments < NewRelic::Cli::Command
   attr_reader :control
   def self.command; "deployments"; end
 
@@ -23,7 +23,7 @@ class NewRelic::Command::Deployments < NewRelic::Command
   # When command_line_args is a hash, we are invoking directly and
   # it's treated as an options with optional string values for
   # :user, :description, :appname, :revision, :environment,
-  # and :changes.
+  # :license_key, and :changes.
   #
   # Will throw CommandFailed exception if there's any error.
   #
@@ -33,8 +33,11 @@ class NewRelic::Command::Deployments < NewRelic::Command
     @description ||= @leftover && @leftover.join(" ")
     @user ||= ENV['USER']
     control.env = @environment if @environment
+
     load_yaml_from_env(control.env)
     @appname ||= NewRelic::Agent.config.app_names[0] || control.env || 'development'
+    @license_key ||= NewRelic::Agent.config[:license_key]
+
     setup_logging(control.env)
   end
 
@@ -68,11 +71,10 @@ class NewRelic::Command::Deployments < NewRelic::Command
 
       uri = "/deployments.xml"
 
-      if NewRelic::Agent.config[:license_key].nil? ||
-          NewRelic::Agent.config[:license_key].empty?
+      if @license_key.nil? || @license_key.empty?
         raise "license_key was not set in newrelic.yml for #{control.env}"
       end
-      request = Net::HTTP::Post.new(uri, {'x-license-key' => NewRelic::Agent.config[:license_key]})
+      request = Net::HTTP::Post.new(uri, {'x-license-key' => @license_key})
       request.content_type = "application/octet-stream"
 
       request.set_form_data(create_params)
@@ -83,18 +85,18 @@ class NewRelic::Command::Deployments < NewRelic::Command
         info "Recorded deployment to '#{@appname}' (#{@description || Time.now })"
       else
         err_string = REXML::Document.new(response.body).elements['errors/error'].map(&:to_s).join("; ") rescue  response.message
-        raise NewRelic::Command::CommandFailure, "Deployment not recorded: #{err_string}"
+        raise NewRelic::Cli::Command::CommandFailure, "Deployment not recorded: #{err_string}"
       end
     rescue SystemCallError, SocketError => e
       # These include Errno connection errors
       err_string = "Transient error attempting to connect to #{control.api_server} (#{e})"
-      raise NewRelic::Command::CommandFailure.new(err_string)
-    rescue NewRelic::Command::CommandFailure
+      raise NewRelic::Cli::Command::CommandFailure.new(err_string)
+    rescue NewRelic::Cli::Command::CommandFailure
       raise
     rescue => e
       err "Unexpected error attempting to connect to #{control.api_server}"
       info "#{e}: #{e.backtrace.join("\n   ")}"
-      raise NewRelic::Command::CommandFailure.new(e.to_s)
+      raise NewRelic::Cli::Command::CommandFailure.new(e.to_s)
     end
   end
 
@@ -114,6 +116,8 @@ class NewRelic::Command::Deployments < NewRelic::Command
              "Default: #{@user || '<none>'}") { | u | @user = u }
       o.on("-r", "--revision=REV", String,
              "Specify the revision being deployed") { | r | @revision = r }
+      o.on("-l", "--license-key=KEY", String,
+             "Specify the license key of the account for the app being deployed") { | l | @license_key = l }
       o.on("-c", "--changes",
              "Read in a change log from the standard input") { @changelog = STDIN.read }
       yield o if block_given?

data/lib/new_relic/{commands → cli}/install.rb

@@ -6,7 +6,7 @@ require 'fileutils'
 require 'new_relic/version'
 require 'erb'
 
-class NewRelic::Command::Install < NewRelic::Command
+class NewRelic::Cli::Install < NewRelic::Cli::Command
 
   NO_LICENSE_KEY = "<PASTE LICENSE KEY HERE>"
 
@@ -40,7 +40,7 @@ class NewRelic::Command::Install < NewRelic::Command
   def run
     dest_file = File.expand_path(@dest_dir + "/newrelic.yml")
     if File.exist?(dest_file)
-      raise NewRelic::Command::CommandFailure, "newrelic.yml file already exists.  Move it out of the way."
+      raise NewRelic::Cli::Command::CommandFailure, "newrelic.yml file already exists.  Move it out of the way."
     end
     File.open(dest_file, 'w') { | out | out.puts(content) }