newrelic_rpm 6.3.0.355 → 9.2.0

data/lib/new_relic/agent/commands/xray_session.rb

@@ -1,55 +0,0 @@
-# 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 'forwardable'
-
-module NewRelic
-  module Agent
-    module Commands
-      class XraySession
-        extend Forwardable
-
-        attr_reader :id, :command_arguments
-        attr_reader :xray_session_name, :key_transaction_name,
-                    :requested_trace_count, :duration, :sample_period
-
-        def initialize(command_arguments)
-          @command_arguments     = command_arguments
-          @id                    = command_arguments.fetch("x_ray_id", nil)
-          @xray_session_name     = command_arguments.fetch("xray_session_name", "")
-          @key_transaction_name  = command_arguments.fetch("key_transaction_name", "")
-          @requested_trace_count = command_arguments.fetch("requested_trace_count", 100)
-          @duration              = command_arguments.fetch("duration", 86400)
-          @sample_period         = command_arguments.fetch("sample_period", 0.1)
-          @run_profiler          = command_arguments.fetch("run_profiler", true)
-        end
-
-        def active?
-          @active
-        end
-
-        def run_profiler?
-          @run_profiler && NewRelic::Agent.config[:'xray_session.allow_profiles']
-        end
-
-        def activate
-          @active = true
-          @start_time = Time.now
-        end
-
-        def deactivate
-          @active = false
-        end
-
-        def requested_period
-          @sample_period
-        end
-
-        def finished?
-          @start_time + @duration < Time.now
-        end
-      end
-    end
-  end
-end

data/lib/new_relic/agent/commands/xray_session_collection.rb

@@ -1,161 +0,0 @@
-# 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 'forwardable'
-require 'thread'
-require 'new_relic/agent/commands/xray_session'
-
-module NewRelic
-  module Agent
-    module Commands
-      class XraySessionCollection
-        extend Forwardable
-
-        def initialize(backtrace_service, event_listener)
-          @backtrace_service = backtrace_service
-
-          # This lock protects access to the sessions hash, but it's expected
-          # that individual session objects within the hash will be manipulated
-          # outside the lock.  This is safe because manipulation of the session
-          # objects is expected from only a single thread (the harvest thread)
-          @sessions_lock = Mutex.new
-          @sessions = {}
-
-          if event_listener
-            event_listener.subscribe(:before_harvest, &method(:cleanup_finished_sessions))
-          end
-        end
-
-        def handle_active_xray_sessions(agent_command)
-          # If X-Rays are disabled, just be quiet about it and don't start the
-          # command. Other hosts might be running the X-Ray, so we don't need
-          # to bark on every get_agent_commands.
-          if !NewRelic::Agent.config[:'xray_session.enabled']
-            NewRelic::Agent.logger.debug("Not responding to X-Ray command because of config 'xray_session.enabled' = #{NewRelic::Agent.config[:'xray_session.enabled']}")
-            return
-          end
-
-          incoming_ids = agent_command.arguments["xray_ids"]
-          deactivate_for_incoming_sessions(incoming_ids)
-          activate_sessions(incoming_ids)
-        end
-
-        def session_id_for_transaction_name(name)
-          @sessions_lock.synchronize do
-            @sessions.each do |id, session|
-              return id if session.key_transaction_name == name
-            end
-          end
-          nil
-        end
-
-        NO_PROFILES = [].freeze
-
-        def harvest_thread_profiles
-          return NO_PROFILES unless NewRelic::Agent::Threading::BacktraceService.is_supported?
-
-          profiles = active_thread_profiling_sessions.map do |session|
-            NewRelic::Agent.logger.debug("Harvesting profile for X-Ray session #{session.inspect}")
-            @backtrace_service.harvest(session.key_transaction_name)
-          end
-          profiles.reject! {|p| p.empty?}
-          profiles.compact
-        end
-
-        def stop_all_sessions
-          deactivate_for_incoming_sessions([])
-        end
-
-        def cleanup_finished_sessions
-          finished_session_ids.each do |id|
-            NewRelic::Agent.logger.debug("Finished X-Ray session #{id} by duration. Removing it from active sessions.")
-            remove_session_by_id(id)
-          end
-        end
-
-
-        ### Internals
-
-        def new_relic_service
-          NewRelic::Agent.instance.service
-        end
-
-        # These are unsynchonized and should only be used for testing
-        def_delegators :@sessions, :[], :include?
-
-        def active_thread_profiling_sessions
-          @sessions_lock.synchronize do
-            @sessions.values.select { |s| s.active? && s.run_profiler? }
-          end
-        end
-
-        ### Session activation
-
-        def activate_sessions(incoming_ids)
-          lookup_metadata_for(ids_to_activate(incoming_ids)).each do |raw|
-            add_session(XraySession.new(raw))
-          end
-        end
-
-        def ids_to_activate(incoming_ids)
-          @sessions_lock.synchronize { incoming_ids - @sessions.keys }
-        end
-
-        # Please don't hold the @sessions_lock across me! Calling the service
-        # is time-consuming, and will block request threads. Which is rude.
-        def lookup_metadata_for(ids_to_activate)
-          return [] if ids_to_activate.empty?
-
-          NewRelic::Agent.logger.debug("Retrieving metadata for X-Ray sessions #{ids_to_activate.inspect}")
-          new_relic_service.get_xray_metadata(ids_to_activate)
-        end
-
-        def add_session(session)
-          NewRelic::Agent.logger.debug("Adding X-Ray session #{session.inspect}")
-          NewRelic::Agent.increment_metric("Supportability/XraySessions/Starts")
-
-          @sessions_lock.synchronize { @sessions[session.id] = session }
-
-          session.activate
-          if session.run_profiler?
-            @backtrace_service.subscribe(session.key_transaction_name, session.command_arguments)
-          end
-        end
-
-        ### Session deactivation
-
-        def deactivate_for_incoming_sessions(incoming_ids)
-          ids_to_remove(incoming_ids).each do |session_id|
-            remove_session_by_id(session_id)
-          end
-        end
-
-        def ids_to_remove(incoming_ids)
-          @sessions_lock.synchronize { @sessions.keys - incoming_ids }
-        end
-
-        def remove_session_by_id(id)
-          session = @sessions_lock.synchronize { @sessions.delete(id) }
-
-          if session
-            NewRelic::Agent.logger.debug("Removing X-Ray session #{session.inspect}")
-            NewRelic::Agent.increment_metric("Supportability/XraySessions/Stops")
-
-            if session.run_profiler?
-              @backtrace_service.unsubscribe(session.key_transaction_name)
-            end
-            session.deactivate
-          end
-        end
-
-        def finished_session_ids
-          @sessions_lock.synchronize do
-            @sessions.map{|k, s| k if s.finished?}.compact
-          end
-        end
-
-      end
-    end
-  end
-end

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

@@ -1,39 +0,0 @@
-# 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 Configuration
-      module EventData
-
-        extend self
-
-        EVENT_DATA_CONFIG_KEY_MAPPING = {
-          :analytic_event_data => :'analytics_events.max_samples_stored',
-          :custom_event_data => :'custom_insights_events.max_samples_stored',
-          :error_event_data => :'error_collector.max_event_samples_stored'
-        }
-
-        def from_config(config)
-          {:harvest_limits => EVENT_DATA_CONFIG_KEY_MAPPING.inject({}) do
-            |event_data, (event_data_key, config_key)|
-              event_data[event_data_key] = config[config_key]
-              event_data
-            end
-          }
-        end
-
-        def to_config_hash(connect_reply)
-          config_hash = EVENT_DATA_CONFIG_KEY_MAPPING.inject({}) do 
-            |event_data, (event_data_key, config_key)|
-              event_data[config_key] = connect_reply['event_data']['harvest_limits'][event_data_key.to_s]
-              event_data
-            end
-          config_hash[:event_report_period] = connect_reply['event_data']['report_period_ms'] / 1000
-          config_hash
-        end
-      end
-    end
-  end
-end

data/lib/new_relic/agent/cross_app_monitor.rb

@@ -1,110 +0,0 @@
-# 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 'digest'
-require 'json'
-
-require 'new_relic/agent/inbound_request_monitor'
-require 'new_relic/agent/tracer'
-require 'new_relic/agent/threading/agent_thread'
-require 'new_relic/agent/cross_app_payload'
-
-module NewRelic
-  module Agent
-    class CrossAppMonitor < InboundRequestMonitor
-
-      NEWRELIC_ID_HEADER      = 'X-NewRelic-ID'.freeze
-      NEWRELIC_TXN_HEADER     = 'X-NewRelic-Transaction'.freeze
-      NEWRELIC_APPDATA_HEADER = 'X-NewRelic-App-Data'.freeze
-
-      NEWRELIC_ID_HEADER_KEY    = 'HTTP_X_NEWRELIC_ID'.freeze
-      NEWRELIC_TXN_HEADER_KEY   = 'HTTP_X_NEWRELIC_TRANSACTION'.freeze
-      CONTENT_LENGTH_HEADER_KEY = 'HTTP_CONTENT_LENGTH'.freeze
-
-      def on_finished_configuring(events)
-        register_event_listeners(events)
-      end
-
-      def path_hash(txn_name, seed)
-        rotated    = ((seed << 1) | (seed >> 31)) & 0xffffffff
-        app_name   = NewRelic::Agent.config.app_names.first
-        identifier = "#{app_name};#{txn_name}"
-        sprintf("%08x", rotated ^ hash_transaction_name(identifier))
-      end
-
-      private
-
-      # Expected sequence of events:
-      #   :before_call will save our cross application request id to the thread
-      #   :after_call will write our response headers/metrics and clean up the thread
-      def register_event_listeners(events)
-        NewRelic::Agent.logger.
-          debug("Wiring up Cross Application Tracing to events after finished configuring")
-
-        events.subscribe(:before_call) do |env| #THREAD_LOCAL_ACCESS
-          if id = decoded_id(env) and should_process_request?(id)
-            state = NewRelic::Agent::Tracer.state
-
-            if (transaction = state.current_transaction)
-              transaction_info = referring_transaction_info(state, env)
-
-              payload = CrossAppPayload.new(id, transaction, transaction_info)
-              transaction.cross_app_payload = payload
-            end
-
-            CrossAppTracing.assign_intrinsic_transaction_attributes state
-          end
-        end
-
-        events.subscribe(:after_call) do |env, (_status_code, headers, _body)| #THREAD_LOCAL_ACCESS
-          state = NewRelic::Agent::Tracer.state
-
-          insert_response_header(state, env, headers)
-        end
-      end
-
-      def referring_transaction_info(state, request_headers)
-        txn_header = request_headers[NEWRELIC_TXN_HEADER_KEY] or return
-        deserialize_header(txn_header, NEWRELIC_TXN_HEADER)
-      end
-
-      def insert_response_header(state, request_headers, response_headers)
-        txn = state.current_transaction
-        unless txn.nil? || txn.cross_app_payload.nil?
-          txn.freeze_name_and_execute_if_not_ignored do
-            content_length = content_length_from_request(request_headers)
-            set_response_headers(txn, response_headers, content_length)
-          end
-        end
-      end
-
-      def should_process_request? id
-        CrossAppTracing.cross_app_enabled? && CrossAppTracing.trusts?(id)
-      end
-
-      def set_response_headers(transaction, response_headers, content_length)
-        payload = obfuscator.obfuscate(
-          ::JSON.dump(
-            transaction.cross_app_payload.as_json_array(content_length)))
-
-        response_headers[NEWRELIC_APPDATA_HEADER] = payload
-      end
-
-      def decoded_id(request)
-        encoded_id = request[NEWRELIC_ID_HEADER_KEY]
-        return "" if encoded_id.nil? || encoded_id.empty?
-
-        obfuscator.deobfuscate(encoded_id)
-      end
-
-      def content_length_from_request(request)
-        request[CONTENT_LENGTH_HEADER_KEY] || -1
-      end
-
-      def hash_transaction_name(identifier)
-        Digest::MD5.digest(identifier).unpack("@12N").first & 0xffffffff
-      end
-    end
-  end
-end

data/lib/new_relic/agent/datastores/mongo/obfuscator.rb

@@ -1,44 +0,0 @@
-# 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 Datastores
-      module Mongo
-        module Obfuscator
-
-          WHITELIST = [:operation].freeze
-
-          def self.obfuscate_statement(source, whitelist = WHITELIST)
-            if source.is_a? Hash
-              obfuscated = {}
-              source.each do |key, value|
-                if whitelist.include?(key)
-                  obfuscated[key] = value
-                else
-                  obfuscated[key] = obfuscate_value(value, whitelist)
-                end
-              end
-              obfuscated
-            else
-              obfuscate_value(source, whitelist)
-            end
-          end
-
-          QUESTION_MARK = '?'.freeze
-
-          def self.obfuscate_value(value, whitelist = WHITELIST)
-            if value.is_a?(Hash)
-              obfuscate_statement(value, whitelist)
-            elsif value.is_a?(Array)
-              value.map {|v| obfuscate_value(v, whitelist)}
-            else
-              QUESTION_MARK
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/new_relic/agent/datastores/mongo/statement_formatter.rb

@@ -1,53 +0,0 @@
-# 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/datastores/mongo/obfuscator'
-
-module NewRelic
-  module Agent
-    module Datastores
-      module Mongo
-        module StatementFormatter
-
-          PLAINTEXT_KEYS = [
-            :database,
-            :collection,
-            :operation,
-            :fields,
-            :skip,
-            :limit,
-            :order
-          ]
-
-          OBFUSCATE_KEYS = [
-            :selector
-          ]
-
-          def self.format(statement, operation)
-            return nil unless NewRelic::Agent.config[:'mongo.capture_queries']
-
-            result = { :operation => operation }
-
-            PLAINTEXT_KEYS.each do |key|
-              result[key] = statement[key] if statement.key?(key)
-            end
-
-            OBFUSCATE_KEYS.each do |key|
-              if statement.key?(key) && statement[key]
-                obfuscated = obfuscate(statement[key])
-                result[key] = obfuscated if obfuscated
-              end
-            end
-            result
-          end
-
-          def self.obfuscate(statement)
-            statement = Obfuscator.obfuscate_statement(statement) if NewRelic::Agent.config[:'mongo.obfuscate_queries']
-            statement
-          end
-        end
-      end
-    end
-  end
-end

data/lib/new_relic/agent/distributed_trace_monitor.rb

@@ -1,40 +0,0 @@
-# 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/inbound_request_monitor'
-require 'new_relic/agent/cross_app_tracing'
-
-module NewRelic
-  module Agent
-    class DistributedTraceMonitor < InboundRequestMonitor
-      def on_finished_configuring(events)
-        return unless NewRelic::Agent.config[:'distributed_tracing.enabled']
-        events.subscribe(:before_call, &method(:on_before_call))
-      end
-
-      NEWRELIC_TRACE_KEY = 'HTTP_NEWRELIC'
-
-      def on_before_call(request)
-        return unless NewRelic::Agent.config[:'distributed_tracing.enabled']
-        return unless payload = request[NEWRELIC_TRACE_KEY]
-        return unless txn = Tracer.current_transaction
-
-        if txn.accept_distributed_trace_payload payload
-          txn.distributed_trace_payload.caller_transport_type = transport_type(request)
-        end
-      end
-
-      URL_SCHEMES = {
-        'http'  => 'HTTP'.freeze,
-        'https' => 'HTTPS'.freeze
-      }
-
-      RACK_URL_SCHEME = 'rack.url_scheme'.freeze
-
-      def transport_type(request)
-        URL_SCHEMES[request[RACK_URL_SCHEME]]
-      end
-    end
-  end
-end