newrelic_rpm 5.5.0.348 → 6.2.0.354

data/lib/new_relic/agent/span_event_primitive.rb

@@ -57,40 +57,46 @@ module NewRelic
       def for_external_request_segment(segment)
         intrinsics = intrinsics_for(segment)
 
-        intrinsics[HTTP_URL_KEY]    = truncate(segment.uri)
         intrinsics[COMPONENT_KEY]   = segment.library
         intrinsics[HTTP_METHOD_KEY] = segment.procedure
         intrinsics[CATEGORY_KEY]    = HTTP_CATEGORY
         intrinsics[SPAN_KIND_KEY]   = CLIENT
 
-        [intrinsics, EMPTY_HASH, EMPTY_HASH]
+        agent_attributes = {}
+
+        if allowed?(HTTP_URL_KEY)
+          agent_attributes[HTTP_URL_KEY] = truncate(segment.uri)
+        end
+
+        [intrinsics, EMPTY_HASH, agent_attributes]
       end
 
       def for_datastore_segment(segment)
         intrinsics = intrinsics_for(segment)
 
         intrinsics[COMPONENT_KEY] = segment.product
+        intrinsics[SPAN_KIND_KEY] = CLIENT
+        intrinsics[CATEGORY_KEY] = DATASTORE_CATEGORY
+
+        agent_attributes = {}
 
-        if segment.database_name
-          intrinsics[DB_INSTANCE_KEY] = truncate(segment.database_name)
+        if segment.database_name && allowed?(DB_INSTANCE_KEY)
+          agent_attributes[DB_INSTANCE_KEY] = truncate(segment.database_name)
         end
-        if segment.host && segment.port_path_or_id
-          intrinsics[PEER_ADDRESS_KEY] = truncate("#{segment.host}:#{segment.port_path_or_id}")
+        if segment.host && segment.port_path_or_id && allowed?(PEER_ADDRESS_KEY)
+          agent_attributes[PEER_ADDRESS_KEY] = truncate("#{segment.host}:#{segment.port_path_or_id}")
         end
-        if segment.host
-          intrinsics[PEER_HOSTNAME_KEY] = truncate(segment.host)
+        if segment.host && allowed?(PEER_HOSTNAME_KEY)
+          agent_attributes[PEER_HOSTNAME_KEY] = truncate(segment.host)
         end
 
-        intrinsics[SPAN_KIND_KEY] = CLIENT
-        intrinsics[CATEGORY_KEY] = DATASTORE_CATEGORY
-
-        if segment.sql_statement
-          intrinsics[DB_STATEMENT_KEY] = truncate(segment.sql_statement.safe_sql, 2000)
-        elsif segment.nosql_statement
-          intrinsics[DB_STATEMENT_KEY] = truncate(segment.nosql_statement, 2000)
+        if segment.sql_statement && allowed?(DB_STATEMENT_KEY)
+          agent_attributes[DB_STATEMENT_KEY] = truncate(segment.sql_statement.safe_sql, 2000)
+        elsif segment.nosql_statement && allowed?(DB_STATEMENT_KEY)
+          agent_attributes[DB_STATEMENT_KEY] = truncate(segment.nosql_statement, 2000)
         end
 
-        [intrinsics, EMPTY_HASH, EMPTY_HASH]
+        [intrinsics, EMPTY_HASH, agent_attributes]
       end
 
       private
@@ -139,6 +145,10 @@ module NewRelic
           value
         end
       end
+
+      def allowed?(key)
+        NewRelic::Agent.instance.attribute_filter.allows_key?(key, AttributeFilter::DST_SPAN_EVENTS)
+      end
     end
   end
 end

data/lib/new_relic/agent/sql_sampler.rb

@@ -61,7 +61,7 @@ module NewRelic
       end
 
       def tl_transaction_data # only used for testing
-        TransactionState.tl_get.sql_sampler_transaction_data
+        Tracer.state.sql_sampler_transaction_data
       end
 
       # This is called when we are done with the transaction.
@@ -141,7 +141,7 @@ module NewRelic
       # @deprecated Use {Datastores.notice_sql} instead.
       #
       def notice_sql(sql, metric_name, config, duration, state=nil, explainer=nil, binds=nil, name=nil) #THREAD_LOCAL_ACCESS sometimes
-        state ||= TransactionState.tl_get
+        state ||= Tracer.state
         data = state.sql_sampler_transaction_data
         return unless data
 
@@ -169,7 +169,7 @@ module NewRelic
       end
 
       def notice_sql_statement(statement, metric_name, duration)
-        state ||= TransactionState.tl_get
+        state ||= Tracer.state
         data = state.sql_sampler_transaction_data
         return unless data
 

data/lib/new_relic/agent/stats_engine.rb

@@ -61,7 +61,7 @@ module NewRelic
       # @api private
       #
       def tl_record_unscoped_metrics(metric_names, value=nil, aux=nil, &blk)
-        state = NewRelic::Agent::TransactionState.tl_get
+        state = NewRelic::Agent::Tracer.state
         record_unscoped_metrics(state, metric_names, value, aux, &blk)
       end
 
@@ -97,7 +97,7 @@ module NewRelic
       # @api private
       #
       def tl_record_scoped_and_unscoped_metrics(scoped_metric, summary_metrics=nil, value=nil, aux=nil, &blk)
-        state = NewRelic::Agent::TransactionState.tl_get
+        state = NewRelic::Agent::Tracer.state
         record_scoped_and_unscoped_metrics(state, scoped_metric, summary_metrics, value, aux, &blk)
       end
 

data/lib/new_relic/agent/synthetics_monitor.rb

@@ -27,8 +27,7 @@ module NewRelic
           SyntheticsMonitor.is_supported_version?(incoming_payload) &&
           SyntheticsMonitor.is_trusted?(incoming_payload)
 
-        state = NewRelic::Agent::TransactionState.tl_get
-        txn = state.current_transaction
+        txn = Tracer.current_transaction
         txn.raw_synthetics_header = encoded_header
         txn.synthetics_payload    = incoming_payload
       end

data/lib/new_relic/agent/system_info.rb

@@ -8,6 +8,7 @@
 # the requested information is unavailable.
 
 require 'rbconfig'
+require 'socket'
 
 module NewRelic
   module Agent
@@ -30,6 +31,10 @@ module NewRelic
 
       @processor_info = nil
 
+      def self.ip_addresses
+        Socket.ip_address_list.map(&:ip_address)
+      end
+
       def self.clear_processor_info
         @processor_info = nil
       end

data/lib/new_relic/agent/threading/agent_thread.rb

@@ -37,7 +37,7 @@ module NewRelic
           if thread.key?(:newrelic_label)
             profile_agent_code ? :agent : :ignore
           else
-            state = TransactionState.tl_state_for(thread)
+            state = Tracer.state_for(thread)
             txn   = state.current_transaction
 
             if    txn && !txn.recording_web_transaction?

data/lib/new_relic/agent/tracer.rb

@@ -0,0 +1,462 @@
+# 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/transaction'
+require 'new_relic/agent/transaction/segment'
+require 'new_relic/agent/transaction/datastore_segment'
+require 'new_relic/agent/transaction/external_request_segment'
+require 'new_relic/agent/transaction/message_broker_segment'
+
+module NewRelic
+  module Agent
+    #
+    # This class helps you interact with the current transaction (if
+    # it exists), start new transactions/segments, etc.
+    #
+    # @api public
+    class Tracer
+      class << self
+        def state
+          state_for(Thread.current)
+        end
+
+        alias_method :tl_get, :state
+
+        # Returns +true+ unless called from within an
+        # +NewRelic::Agent.disable_all_tracing+ block.
+        #
+        # @api public
+        def tracing_enabled?
+          state.tracing_enabled?
+        end
+
+        # Returns the transaction in progress for this thread, or
+        # +nil+ if none exists.
+        #
+        # @api public
+        def current_transaction
+          state.current_transaction
+        end
+
+        # Runs the given block of code in a transaction.
+        #
+        # @param [String] name reserved for New Relic internal use
+        #
+        # @param [String] partial_name a meaningful name for this
+        #   transaction (e.g., +blogs/index+); the Ruby agent will add a
+        #   New-Relic-specific prefix
+        #
+        # @param [Symbol] category +:web+ for web transactions or
+        #   +:background+ for background transactions
+        #
+        # @param [Hash] options reserved for New Relic internal use
+        #
+        # @api public
+        def in_transaction(name: nil,
+                           partial_name: nil,
+                           category: nil,
+                           options: {})
+
+          finishable = start_transaction_or_segment(
+            name: name,
+            partial_name: partial_name,
+            category: category,
+            options: options
+          )
+
+          begin
+            # We shouldn't raise from Tracer.start_transaction_or_segment, but
+            # only wrap the yield to be absolutely sure we don't report agent
+            # problems as app errors
+            yield
+          rescue => e
+            current_transaction.notice_error(e)
+            raise e
+          ensure
+            finishable.finish if finishable
+          end
+        end
+
+        # Starts a segment on the current transaction (if one exists)
+        # or starts a new transaction otherwise.
+        #
+        # @param [String] name reserved for New Relic internal use
+        #
+        # @param [String] partial_name a meaningful name for this
+        #   transaction (e.g., +blogs/index+); the Ruby agent will add a
+        #   New-Relic-specific prefix
+        #
+        # @param [Symbol] category +:web+ for web transactions or
+        #   +:background+ for background transactions
+        #
+        # @param [Hash] options reserved for New Relic internal use
+        #
+        # @return [Object, #finish] an object that responds to
+        #   +finish+; you _must_ call +finish+ on it at the end of the
+        #   code you're tracing
+        #
+        # @api public
+        def start_transaction_or_segment(name: nil,
+                                         partial_name: nil,
+                                         category: nil,
+                                         options: {})
+          if name.nil? && partial_name.nil?
+            raise ArgumentError, 'missing required argument: name or partial_name'
+          end
+          if category.nil?
+            raise ArgumentError, 'missing required argument: category'
+          end
+
+          if name
+            options[:transaction_name] = name
+          else
+            options[:transaction_name] = Transaction.name_from_partial(
+              partial_name,
+              category
+            )
+          end
+
+          if (txn = current_transaction)
+            txn.create_nested_segment(category, options)
+          else
+            Transaction.start_new_transaction(state, category, options)
+          end
+
+        rescue ArgumentError
+          raise
+        rescue => e
+          log_error('start_transaction_or_segment', e)
+        end
+
+        # Takes name or partial_name and a category.
+        # Returns a transaction instance or nil
+        def start_transaction(name: nil,
+                              partial_name: nil,
+                              category: nil,
+                              **options)
+          if name.nil? && partial_name.nil?
+            raise ArgumentError, 'missing required argument: name or partial_name'
+          end
+          if category.nil?
+            raise ArgumentError, 'missing required argument: category'
+          end
+
+          return current_transaction if current_transaction
+
+          if name
+            options[:transaction_name] = name
+          else
+            options[:transaction_name] = Transaction.name_from_partial(
+              partial_name,
+              category
+            )
+          end
+
+          Transaction.start_new_transaction(state,
+                                            category,
+                                            options)
+        rescue ArgumentError
+          raise
+        rescue => e
+          log_error('start_transaction', e)
+        end
+
+        def create_distributed_trace_payload
+          return unless txn = current_transaction
+          txn.create_distributed_trace_payload
+        end
+
+        def accept_distributed_trace_payload(payload)
+          return unless txn = current_transaction
+          txn.accept_distributed_trace_payload(payload)
+        end
+
+        # Returns the currently active segment in the transaction in
+        # progress for this thread, or +nil+ if no segment or
+        # transaction exists.
+        #
+        # @api public
+        def current_segment
+          return unless txn = current_transaction
+          txn.current_segment
+        end
+
+        # Creates and starts a general-purpose segment used to time
+        # arbitrary code.
+        #
+        # @param [String] name full name of the segment; the agent
+        #   will not add a prefix. Third-party users should begin the
+        #   name with +Custom/+; e.g.,
+        #   +Custom/UserMailer/send_welcome_email+
+        #
+        # @param [optional, String, Array] unscoped_metrics additional
+        #   unscoped metrics to record using this segment's timing
+        #   information
+        #
+        # @param start_time [optional, Time] a +Time+ instance
+        #   denoting the start time of the segment. Value is set by
+        #   AbstractSegment#start if not given.
+        #
+        # @param parent [optional, Segment] Use for the rare cases
+        #   (such as async) where the parent segment should be something
+        #   other than the current segment
+        #
+        # @return [Segment] the newly created segment; you _must_ call
+        #   +finish+ on it at the end of the code you're tracing
+        #
+        # @api public
+        def start_segment(name:nil,
+                          unscoped_metrics:nil,
+                          start_time: nil,
+                          parent: nil)
+
+          # ruby 2.0.0 does not support required kwargs
+          raise ArgumentError, 'missing required argument: name' if name.nil?
+
+          segment = Transaction::Segment.new name, unscoped_metrics, start_time
+          start_and_add_segment segment, parent
+
+        rescue ArgumentError
+          raise
+        rescue => e
+          log_error('start_segment', e)
+        end
+
+        UNKNOWN = "Unknown".freeze
+        OTHER = "other".freeze
+
+        # Creates and starts a datastore segment used to time
+        # datastore operations.
+        #
+        # @param [String] product the datastore name for use in metric
+        #   naming, e.g. "FauxDB"
+        #
+        # @param [String] operation the name of the operation
+        #   (e.g. "select"), often named after the method that's being
+        #   instrumented.
+        #
+        # @param [optional, String] collection the collection name for use in
+        #   statement-level metrics (i.e. table or model name)
+        #
+        # @param [optional, String] host the host this database
+        #   instance is running on
+        #
+        # @param [optional, String] port_path_or_id TCP port, file
+        #   path, UNIX domain socket, or other connection-related info
+        #
+        # @param [optional, String] database_name the name of this
+        #   database
+        #
+        # @param start_time [optional, Time] a +Time+ instance
+        #   denoting the start time of the segment. Value is set by
+        #   AbstractSegment#start if not given.
+        #
+        # @param parent [optional, Segment] Use for the rare cases
+        #   (such as async) where the parent segment should be something
+        #   other than the current segment
+        #
+        # @return [DatastoreSegment] the newly created segment; you
+        #   _must_ call +finish+ on it at the end of the code you're
+        #   tracing
+        #
+        # @api public
+        def start_datastore_segment(product: nil,
+                                    operation: nil,
+                                    collection: nil,
+                                    host: nil,
+                                    port_path_or_id: nil,
+                                    database_name: nil,
+                                    start_time: nil,
+                                    parent: nil)
+
+          product ||= UNKNOWN
+          operation ||= OTHER
+
+          segment = Transaction::DatastoreSegment.new product, operation, collection, host, port_path_or_id, database_name
+          start_and_add_segment segment, parent
+
+        rescue ArgumentError
+          raise
+        rescue => e
+          log_error('start_datastore_segment', e)
+        end
+
+        # Creates and starts an external request segment using the
+        # given library, URI, and procedure. This is used to time
+        # external calls made over HTTP.
+        #
+        # @param [String] library a string of the class name of the library used to
+        #   make the external call, for example, 'Net::HTTP'.
+        #
+        # @param [String, URI] uri indicates the URI to which the
+        #   external request is being made. The URI should begin with the protocol,
+        #   for example, 'https://github.com'.
+        #
+        # @param [String] procedure the HTTP method being used for the external
+        #   request as a string, for example, 'GET'.
+        #
+        # @param start_time [optional, Time] a +Time+ instance
+        #   denoting the start time of the segment. Value is set by
+        #   AbstractSegment#start if not given.
+        #
+        # @param parent [optional, Segment] Use for the rare cases
+        #   (such as async) where the parent segment should be something
+        #   other than the current segment
+        #
+        # @return [ExternalRequestSegment] the newly created segment;
+        #   you _must_ call +finish+ on it at the end of the code
+        #   you're tracing
+        #
+        # @api public
+        def start_external_request_segment(library: nil,
+                                           uri: nil,
+                                           procedure: nil,
+                                           start_time: nil,
+                                           parent: nil)
+
+          # ruby 2.0.0 does not support required kwargs
+          raise ArgumentError, 'missing required argument: library' if library.nil?
+          raise ArgumentError, 'missing required argument: uri' if uri.nil?
+          raise ArgumentError, 'missing required argument: procedure' if procedure.nil?
+
+          segment = Transaction::ExternalRequestSegment.new library, uri, procedure, start_time
+          start_and_add_segment segment, parent
+
+        rescue ArgumentError
+          raise
+        rescue => e
+          log_error('start_external_request_segment', e)
+        end
+
+        # For New Relic internal use only.
+        def start_message_broker_segment(action: nil,
+                                         library: nil,
+                                         destination_type: nil,
+                                         destination_name: nil,
+                                         headers: nil,
+                                         parameters: nil,
+                                         start_time: nil,
+                                         parent: nil)
+
+          # ruby 2.0.0 does not support required kwargs
+          raise ArgumentError, 'missing required argument: action' if action.nil?
+          raise ArgumentError, 'missing required argument: library' if library.nil?
+          raise ArgumentError, 'missing required argument: destination_type' if destination_type.nil?
+          raise ArgumentError, 'missing required argument: destination_name' if destination_name.nil?
+
+          segment = Transaction::MessageBrokerSegment.new(
+            action: action,
+            library: library,
+            destination_type: destination_type,
+            destination_name: destination_name,
+            headers: headers,
+            parameters: parameters,
+            start_time: start_time
+          )
+          start_and_add_segment segment, parent
+
+        rescue ArgumentError
+          raise
+        rescue => e
+          log_error('start_datastore_segment', e)
+        end
+
+        # This method should only be used by Tracer 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 state_for(thread)
+          state = thread[:newrelic_tracer_state]
+
+          if state.nil?
+            state = Tracer::State.new
+            thread[:newrelic_tracer_state] = state
+          end
+
+          state
+        end
+
+        alias_method :tl_state_for, :state_for
+
+        def clear_state
+          Thread.current[:newrelic_tracer_state] = nil
+        end
+
+        alias_method :tl_clear, :clear_state
+
+        private
+
+        def start_and_add_segment segment, parent = nil
+          tracer_state = state
+          if (txn = tracer_state.current_transaction) &&
+            tracer_state.tracing_enabled?
+            txn.add_segment segment, parent
+          else
+            segment.record_metrics = false
+          end
+          segment.start
+          segment
+        end
+
+        def log_error(method_name, exception)
+          NewRelic::Agent.logger.error("Exception during Tracer.#{method_name}", exception)
+          nil
+        end
+      end
+
+      # 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 State
+
+        def initialize
+          @untraced = []
+          @current_transaction = nil
+          @record_sql = nil
+        end
+
+        # This starts the timer for the transaction.
+        def reset(transaction=nil)
+          # We purposefully don't reset @untraced or @record_sql
+          # since those are managed by NewRelic::Agent.disable_* calls explicitly
+          # and (more importantly) outside the scope of a transaction
+
+          @current_transaction = transaction
+          @sql_sampler_transaction_data = nil
+        end
+
+        # Current transaction stack
+        attr_reader :current_transaction
+
+        # Execution tracing on current thread
+        attr_accessor :untraced
+
+        def push_traced(should_trace)
+          @untraced << should_trace
+        end
+
+        def pop_traced
+          @untraced.pop if @untraced
+        end
+
+        def is_execution_traced?
+          @untraced.nil? || @untraced.last != false
+        end
+
+        alias_method :tracing_enabled?, :is_execution_traced?
+
+        # TT's and SQL
+        attr_accessor :record_sql
+
+        def is_sql_recorded?
+          @record_sql != false
+        end
+
+        # Sql Sampler Transaction Data
+        attr_accessor :sql_sampler_transaction_data
+      end
+    end
+
+    TransactionState = Tracer
+  end
+end