newrelic_rpm 4.0.0.332 → 4.8.0.341

data/lib/new_relic/agent/transaction_sampler.rb

@@ -2,11 +2,10 @@
 # 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/transaction_sample_builder'
-require 'new_relic/agent/transaction/developer_mode_sample_buffer'
 require 'new_relic/agent/transaction/slowest_sample_buffer'
 require 'new_relic/agent/transaction/synthetics_sample_buffer'
 require 'new_relic/agent/transaction/xray_sample_buffer'
+require 'new_relic/agent/transaction/trace_builder'
 
 module NewRelic
   module Agent
@@ -20,14 +19,12 @@ module NewRelic
     #
     # @api public
     class TransactionSampler
-      attr_reader :last_sample, :dev_mode_sample_buffer, :xray_sample_buffer
+      attr_reader :last_sample, :xray_sample_buffer
 
       def initialize
-        @dev_mode_sample_buffer = NewRelic::Agent::Transaction::DeveloperModeSampleBuffer.new
         @xray_sample_buffer = NewRelic::Agent::Transaction::XraySampleBuffer.new
 
         @sample_buffers = []
-        @sample_buffers << @dev_mode_sample_buffer
         @sample_buffers << @xray_sample_buffer
         @sample_buffers << NewRelic::Agent::Transaction::SlowestSampleBuffer.new
         @sample_buffers << NewRelic::Agent::Transaction::SyntheticsSampleBuffer.new
@@ -54,37 +51,7 @@ module NewRelic
       end
 
       def enabled?
-        Agent.config[:'transaction_tracer.enabled'] || Agent.config[:developer_mode]
-      end
-
-      def on_start_transaction(state, start_time)
-        if enabled?
-          start_builder(state, start_time.to_f)
-        end
-      end
-
-      # This delegates to the builder to create a new open transaction node
-      # for the frame, beginning at the optionally specified time.
-      #
-      # Note that in developer mode, this captures a stacktrace for
-      # the beginning of each node, which can be fairly slow
-      def notice_push_frame(state, time=Time.now)
-        builder = state.transaction_sample_builder
-        return unless builder
-
-        node = builder.trace_entry(time.to_f)
-        if @dev_mode_sample_buffer
-          @dev_mode_sample_buffer.visit_node(node)
-        end
-        node
-      end
-
-      # Informs the transaction sample builder about the end of a traced frame
-      def notice_pop_frame(state, frame, time = Time.now)
-        builder = state.transaction_sample_builder
-        return unless builder
-        raise "finished already???" if builder.sample.finished
-        builder.trace_exit(frame, time.to_f)
+        Agent.config[:'transaction_tracer.enabled']
       end
 
       # This is called when we are done with the transaction.  We've
@@ -95,23 +62,11 @@ module NewRelic
       # It sets various instance variables to the finished sample,
       # depending on which settings are active. See `store_sample`
       def on_finishing_transaction(state, txn, time=Time.now)
-        last_builder = state.transaction_sample_builder
-        return unless last_builder && enabled?
-
-        state.transaction_sample_builder = nil
-        return if txn.ignore_trace?
-
-        last_builder.finish_trace(time.to_f)
-
-        last_sample = last_builder.sample
-        last_sample.transaction_name = txn.best_name
-        last_sample.uri = txn.request_path
-        last_sample.guid = txn.guid
-        last_sample.attributes = txn.attributes
+        return if !enabled? || txn.ignore_trace?
 
         @samples_lock.synchronize do
-          @last_sample = last_sample
-          store_sample(@last_sample)
+          @last_sample = txn
+          store_sample(txn)
           @last_sample
         end
       end
@@ -122,118 +77,6 @@ module NewRelic
         end
       end
 
-      MAX_DATA_LENGTH = 16384
-      # This method is used to record metadata into the currently
-      # active node like a sql query, memcache key, or Net::HTTP uri
-      #
-      # duration is seconds, float value.
-      def notice_extra_data(builder, message, duration, key)
-        return unless builder
-        node = builder.current_node
-        if node
-          if key == :sql
-            statement = node[:sql]
-            if(statement && !statement.sql.empty?)
-              statement.sql = self.class.truncate_message(statement.sql + "\n#{message.sql}") if statement.sql.length <= MAX_DATA_LENGTH
-            else
-              # message is expected to have been pre-truncated by notice_sql
-              node[:sql] = message
-            end
-          else
-            node[key] = self.class.truncate_message(message)
-          end
-          append_backtrace(node, duration)
-        end
-      end
-
-      private :notice_extra_data
-
-      # Truncates the message to `MAX_DATA_LENGTH` if needed, and
-      # appends an ellipsis because it makes the trucation clearer in
-      # the UI
-      def self.truncate_message(message)
-        if message.length > (MAX_DATA_LENGTH - 4)
-          message.slice!(MAX_DATA_LENGTH - 4..message.length)
-          message << "..."
-        else
-          message
-        end
-      end
-
-      # Appends a backtrace to a node if that node took longer
-      # than the specified duration
-      def append_backtrace(node, duration)
-        if duration >= Agent.config[:'transaction_tracer.stack_trace_threshold']
-          node[:backtrace] = caller.join("\n")
-        end
-      end
-
-      # Attaches an SQL query on the current transaction trace node.
-      #
-      # This method should be used only by gem authors wishing to extend
-      # the Ruby agent to instrument new database interfaces - it should
-      # generally not be called directly from application code.
-      #
-      # @param sql [String] the SQL query being recorded
-      # @param config [Object] the driver configuration for the connection
-      # @param duration [Float] number of seconds the query took to execute
-      # @param explainer [Proc] for internal use only - 3rd-party clients must
-      #                         not pass this parameter.
-      #
-      # @api public
-      # @deprecated Use {Datastores.notice_sql} instead.
-      #
-      def notice_sql(sql, config, duration, state=nil, explainer=nil, binds=nil, name=nil) #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, binds, name)
-          notice_extra_data(builder, statement, duration, :sql)
-        end
-      end
-
-
-      def notice_sql_statement(statement, duration) #THREAD_LOCAL_ACCESS sometimes
-        state ||= TransactionState.tl_get
-        builder = state.transaction_sample_builder
-        notice_extra_data(builder, statement, duration, :sql)
-      end
-
-      # Attaches an additional non-SQL query parameter to the current
-      # transaction trace node.
-      #
-      # This may be used for recording a query against a key-value store like
-      # memcached or redis.
-      #
-      # This method should be used only by gem authors wishing to extend
-      # the Ruby agent to instrument uninstrumented key-value stores - it should
-      # generally not be called directly from application code.
-      #
-      # @param key [String] the name of the key that was queried
-      # @param duration [Float] number of seconds the query took to execute
-      #
-      # @api public
-      # @deprecated Use {Datastores.notice_statement} instead.
-      #
-      def notice_nosql(key, duration) #THREAD_LOCAL_ACCESS
-        builder = tl_builder
-        notice_extra_data(builder, key, duration, :key)
-      end
-
-      def notice_nosql_statement(statement, duration) #THREAD_LOCAL_ACCESS
-        builder = tl_builder
-        notice_extra_data(builder, statement, duration, :statement)
-      end
-
-      # Set parameters on the current node.
-      def add_node_parameters(params) #THREAD_LOCAL_ACCESS
-        builder = tl_builder
-        return unless builder
-        params.each { |k,v| builder.current_node[k] = v }
-      end
-
       # Gather transaction traces that we'd like to transmit to the server.
       def harvest!
         return [] unless enabled?
@@ -279,7 +122,14 @@ module NewRelic
         # know, Ruby 1.8.6 :/
         result = []
         @sample_buffers.each { |buffer| result.concat(buffer.harvest_samples) }
-        result.uniq
+        result.uniq!
+        result.map! do |sample|
+          if Transaction === sample
+            Transaction::TraceBuilder.build_trace sample
+          else
+            sample
+          end
+        end
       end
 
       # reset samples without rebooting the web server (used by dev mode)
@@ -289,25 +139,6 @@ module NewRelic
           @sample_buffers.each { |sample_buffer| sample_buffer.reset! }
         end
       end
-
-      # Checks to see if the transaction sampler is disabled, if
-      # transaction trace recording is disabled by a thread local, or
-      # if execution is untraced - if so it clears the transaction
-      # sample builder from the thread local, otherwise it generates a
-      # new transaction sample builder with the stated time as a
-      # starting point and saves it in the thread local variable
-      def start_builder(state, time=nil)
-        if !enabled? || !state.is_transaction_traced? || !state.is_execution_traced?
-          state.transaction_sample_builder = nil
-        else
-          state.transaction_sample_builder ||= TransactionSampleBuilder.new(time)
-        end
-      end
-
-      # The current thread-local transaction sample builder
-      def tl_builder
-        TransactionState.tl_get.transaction_sample_builder
-      end
     end
   end
 end

data/lib/new_relic/agent/transaction_state.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/traced_method_stack'
-
 module NewRelic
   module Agent
 
@@ -29,13 +27,12 @@ module NewRelic
         state
       end
 
-      def self.tl_clear_for_testing
+      def self.tl_clear
         Thread.current[:newrelic_transaction_state] = nil
       end
 
       def initialize
         @untraced = []
-        @traced_method_stack = TracedMethodStack.new
         @current_transaction = nil
         @record_tt = nil
         @record_sql = nil
@@ -51,13 +48,11 @@ module NewRelic
         @request = nil
         @current_transaction = transaction
 
-        @traced_method_stack.clear
 
         @is_cross_app_caller = false
         @client_cross_app_id = nil
         @referring_transaction_info = nil
 
-        @transaction_sample_builder = nil
         @sql_sampler_transaction_data = nil
 
         @busy_entries = 0
@@ -91,9 +86,8 @@ module NewRelic
         current_transaction.guid
       end
 
-      # Current transaction stack and sample building
+      # Current transaction stack
       attr_reader   :current_transaction
-      attr_accessor :transaction_sample_builder
 
       def transaction_start_time
         current_transaction.start_time if current_transaction
@@ -146,10 +140,6 @@ module NewRelic
 
       # 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_reader :traced_method_stack
     end
   end
 end

data/lib/new_relic/agent/utilization/aws.rb

@@ -0,0 +1,18 @@
+# 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/utilization/vendor'
+
+module NewRelic
+  module Agent
+    module Utilization
+      class AWS < Vendor
+        vendor_name "aws"
+        endpoint "http://169.254.169.254/2016-09-02/dynamic/instance-identity/document"
+        keys ["instanceId", "instanceType", "availabilityZone"]
+        key_transforms :to_sym
+      end
+    end
+  end
+end

data/lib/new_relic/agent/utilization/azure.rb

@@ -0,0 +1,17 @@
+# 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
+    module Utilization
+      class Azure < Vendor
+        vendor_name "azure"
+        endpoint "http://169.254.169.254/metadata/instance/compute?api-version=2017-03-01"
+        headers "Metadata" => "true"
+        keys ["vmId", "name", "vmSize", "location"]
+        key_transforms :to_sym
+      end
+    end
+  end
+end

data/lib/new_relic/agent/utilization/gcp.rb

@@ -0,0 +1,35 @@
+# 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/utilization/vendor'
+
+module NewRelic
+  module Agent
+    module Utilization
+      class GCP < Vendor
+        vendor_name "gcp"
+        endpoint "http://metadata.google.internal/computeMetadata/v1/instance/?recursive=true"
+        headers "Metadata-Flavor" => "Google"
+        keys ["id", "machineType", "name", "zone"]
+        key_transforms :to_sym
+
+        MACH_TYPE = 'machineType'.freeze
+        ZONE = 'zone'.freeze
+
+        def prepare_response response
+          body = JSON.parse response.body
+          body[MACH_TYPE] = trim_leading body[MACH_TYPE]
+          body[ZONE] = trim_leading body[ZONE]
+          body
+        end
+
+        SLASH = '/'.freeze
+
+        def trim_leading value
+          value.split(SLASH).last
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/utilization/pcf.rb

@@ -0,0 +1,32 @@
+# 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/utilization/vendor'
+
+module NewRelic
+  module Agent
+    module Utilization
+      class PCF < Vendor
+        vendor_name "pcf"
+        keys ["CF_INSTANCE_GUID", "CF_INSTANCE_IP", "MEMORY_LIMIT"]
+        key_transforms [:downcase, :to_sym]
+
+        def detect
+          begin
+            return false unless pcf_keys_present?
+            process_response ENV
+          rescue
+            NewRelic::Agent.logger.error "Error occurred detecting: #{vendor_name}", e
+            record_supportability_metric
+            false
+          end
+        end
+
+        def pcf_keys_present?
+          !(ENV.keys & keys).empty?
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/utilization/vendor.rb

@@ -0,0 +1,144 @@
+# 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 'net/http'
+
+module NewRelic
+  module Agent
+    module Utilization
+      class Vendor
+        class << self
+          def vendor_name vendor_name = nil
+            vendor_name ? @vendor_name = vendor_name.freeze : @vendor_name
+          end
+
+          def endpoint endpoint = nil
+            endpoint ? @endpoint = URI(endpoint) : @endpoint
+          end
+
+          def headers headers = nil
+            headers ? @headers = headers.freeze : @headers
+          end
+
+          def keys keys = nil
+            keys ? @keys = keys.freeze : @keys
+          end
+
+          def key_transforms key_transforms = nil
+            key_transforms ? @key_transforms = Array(key_transforms).freeze : @key_transforms
+          end
+        end
+
+        attr_reader :metadata
+
+        def initialize
+          @metadata = {}
+        end
+
+        [:vendor_name, :endpoint, :headers, :keys, :key_transforms].each do |method_name|
+          define_method(method_name) { self.class.send(method_name) }
+        end
+
+        SUCCESS = '200'.freeze
+
+        def detect
+          response = request_metadata
+          return false unless response
+
+          begin
+            if response.code == SUCCESS
+              process_response prepare_response(response)
+            else
+              false
+            end
+          rescue => e
+            NewRelic::Agent.logger.error "Error occurred detecting: #{vendor_name}", e
+            record_supportability_metric
+            false
+          end
+        end
+
+        private
+
+        def request_metadata
+          Timeout.timeout 1 do
+            response = nil
+            Net::HTTP.start endpoint.host, endpoint.port do |http|
+              req = Net::HTTP::Get.new endpoint, headers
+              response = http.request req
+            end
+            response
+          end
+        rescue
+          NewRelic::Agent.logger.debug "#{vendor_name} environment not detected"
+        end
+
+        def prepare_response response
+          JSON.parse response.body
+        end
+
+        def process_response response
+          keys.each do |key|
+            normalized = normalize response[key]
+            if normalized
+              @metadata[transform_key(key)] = normalized
+            else
+              @metadata.clear
+              record_supportability_metric
+              return false
+            end
+          end
+          true
+        end
+
+        def normalize value
+          return if value.nil?
+
+          value = value.to_s
+          value = value.dup if value.frozen?
+
+          value.force_encoding Encoding::UTF_8
+          value.strip!
+
+          return unless valid_length? value
+          return unless valid_chars? value
+
+          value
+        end
+
+        def valid_length? value
+          if value.bytesize <= 255
+            true
+          else
+            NewRelic::Agent.logger.warn "Found invalid length value while detecting: #{vendor_name}"
+            false
+          end
+        end
+
+        VALID_CHARS = /^[0-9a-zA-Z_ .\/-]$/
+
+        def valid_chars? value
+          value.each_char do |ch|
+            next if ch =~ VALID_CHARS
+            code_point = ch[0].ord # this works in Ruby 1.8.7 - 2.1.2
+            next if code_point >= 0x80
+
+            NewRelic::Agent.logger.warn "Found invalid character while detecting: #{vendor_name}"
+            return false # it's in neither set of valid characters
+          end
+          true
+        end
+
+        def transform_key key
+          return key unless key_transforms
+          key_transforms.inject(key) { |memo, transform| memo.send(transform) }
+        end
+
+        def record_supportability_metric
+          NewRelic::Agent.increment_metric "Supportability/utilization/#{vendor_name}/error"
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/utilization_data.rb

@@ -2,12 +2,22 @@
 # 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/aws_info'
+require 'new_relic/agent/utilization/aws'
+require 'new_relic/agent/utilization/gcp'
+require 'new_relic/agent/utilization/azure'
+require 'new_relic/agent/utilization/pcf'
 
 module NewRelic
   module Agent
     class UtilizationData
-      METADATA_VERSION = 2
+      METADATA_VERSION = 3
+
+      VENDORS = {
+        Utilization::AWS   => :'utilization.detect_aws',
+        Utilization::GCP   => :'utilization.detect_gcp',
+        Utilization::Azure => :'utilization.detect_azure',
+        Utilization::PCF   => :'utilization.detect_pcf'
+      }
 
       def hostname
         NewRelic::Agent::Hostname.get
@@ -55,21 +65,24 @@ module NewRelic
           :hostname => hostname
         }
 
-        append_aws_info(result)
+        append_vendor_info(result)
         append_docker_info(result)
         append_configured_values(result)
+        append_boot_id(result)
 
         result
       end
 
-      def append_aws_info(collector_hash)
-        return unless Agent.config[:'utilization.detect_aws']
-
-        aws_info = AWSInfo.new
+      def append_vendor_info(collector_hash)
+        VENDORS.each_pair do |klass, config_option|
+          next unless Agent.config[config_option]
+          vendor = klass.new
 
-        if aws_info.loaded?
-          collector_hash[:vendors] ||= {}
-          collector_hash[:vendors][:aws] = aws_info.to_collector_hash
+          if vendor.detect
+            collector_hash[:vendors] ||= {}
+            collector_hash[:vendors][vendor.vendor_name.to_sym] = vendor.metadata
+            break
+          end
         end
       end
 
@@ -86,6 +99,12 @@ module NewRelic
         collector_hash[:config] = config_hash unless config_hash.empty?
       end
 
+      def append_boot_id(collector_hash)
+        if bid = ::NewRelic::Agent::SystemInfo.boot_id
+          collector_hash[:boot_id] = bid
+        end
+      end
+
       def config_hash
         config_hash = {}