newrelic_rpm 9.23.0 → 10.0.0

data/lib/new_relic/agent/monitors/cross_app_monitor.rb

@@ -1,117 +0,0 @@
-# This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
-# frozen_string_literal: true
-
-require 'digest'
-require 'json'
-
-require 'new_relic/agent/tracer'
-require 'new_relic/agent/threading/agent_thread'
-
-module NewRelic
-  module Agent
-    module DistributedTracing
-      class CrossAppMonitor < InboundRequestMonitor
-        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)
-          if CrossAppTracing.cross_app_enabled?
-            Deprecator.deprecate('cross_application_tracer')
-            ::NewRelic::Agent.logger.warn(
-              '[DEPRECATED] Cross application tracing is enabled. Distributed tracing is replacing cross application tracing as the default means of tracing between services. To continue using cross application tracing, enable it with `cross_application_tracer.enabled: true` and `distributed_tracing.enabled: false`'
-            )
-          end
-
-          register_event_listeners(events)
-        end
-
-        def path_hash(txn_name, seed)
-          rotated = ((seed << 1) | (seed >> 31)) & 0xffffffff
-          app_name = NewRelic::Agent.config[:app_name].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 (txn = state.current_transaction)
-                transaction_info = referring_transaction_info(state, env)
-
-                payload = CrossAppPayload.new(id, txn, transaction_info)
-                txn.distributed_tracer.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.distributed_tracer.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.distributed_tracer.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 NewRelic::EMPTY_STR 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
-end

data/lib/new_relic/agent/new_relic_service/security_policy_settings.rb

@@ -1,61 +0,0 @@
-# This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
-# frozen_string_literal: true
-
-module NewRelic
-  module Agent
-    class NewRelicService
-      module SecurityPolicySettings
-        EXPECTED_SECURITY_POLICIES = %w[
-          record_sql
-          attributes_include
-          allow_raw_exception_messages
-          custom_events
-          custom_parameters
-          custom_instrumentation_editor
-          message_parameters
-        ].map(&:freeze)
-
-        def self.preliminary_settings(security_policies)
-          enabled_key = 'enabled'.freeze
-          settings = EXPECTED_SECURITY_POLICIES.inject({}) do |memo, policy_name|
-            memo[policy_name] = {enabled_key => security_policies[policy_name][enabled_key]}
-            memo
-          end
-          {'security_policies' => settings}
-        end
-
-        class Validator
-          def initialize(preconnect_response)
-            @preconnect_policies = preconnect_response['security_policies'] || {}
-          end
-
-          def validate_matching_agent_config!
-            agent_keys = EXPECTED_SECURITY_POLICIES
-            all_server_keys = @preconnect_policies.keys
-            required = 'required'
-            required_server_keys = @preconnect_policies.keys.select do |key|
-              key if @preconnect_policies[key][required]
-            end
-
-            missing_from_agent = required_server_keys - agent_keys
-            unless missing_from_agent.empty?
-              message = "The agent received one or more required security policies \
-that it does not recognize and will shut down: #{missing_from_agent.join(',')}. \
-Please check if a newer agent version supports these policies or contact support."
-              raise NewRelic::Agent::UnrecoverableAgentException.new(message)
-            end
-
-            missing_from_server = agent_keys - all_server_keys
-            unless missing_from_server.empty?
-              message = "The agent did not receive one or more security policies \
-that it expected and will shut down: #{missing_from_server.join(',')}. Please \
-contact support."
-              raise NewRelic::Agent::UnrecoverableAgentException.new(message)
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/new_relic/cli/commands/deployments.rb

@@ -1,206 +0,0 @@
-# This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
-# frozen_string_literal: true
-
-# This is a class for executing commands related to deployment
-# events.  It runs without loading the rails environment
-
-require 'yaml'
-require 'net/http'
-require 'new_relic/agent/hostname'
-
-# We need to use the Control object but we don't want to load
-# the rails environment.  The defined? clause is so that
-# it won't load it twice, something it does when run inside a test
-require 'new_relic/control' unless defined? NewRelic::Control
-
-class NewRelic::Cli::Deployments < NewRelic::Cli::Command
-  # DEPRECATION NOTICE (Effective September 2025)
-  #
-  # The entire `NewRelic::Cli::Deployments` class and its associated
-  # `newrelic deployments` command are deprecated and will be removed in
-  # agent version 10.0.0.
-  #
-  # Users should migrate to recording deployments directly via New Relic's
-  # APIs. For more information, please see the official Change Tracking
-  # documentation: https://docs.newrelic.com/docs/change-tracking/change-tracking-introduction/
-  #
-  # @api public
-  #
-
-  attr_reader :control
-  def self.command; 'deployments'; end
-
-  # Initialize the deployment uploader with command line args.
-  # Use -h to see options.
-  # 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,
-  # :license_key, and :changes.
-  #
-  # Will throw CommandFailed exception if there's any error.
-  #
-  def initialize(command_line_args)
-    @control = NewRelic::Control.instance
-    @environment = nil
-    @changelog = nil
-    @user = nil
-    super(command_line_args)
-    # needs else branch coverage
-    @description ||= @leftover && @leftover.join(' ') # rubocop:disable Style/SafeNavigation
-    @user ||= ENV['USER']
-    control.env = @environment if @environment
-
-    load_yaml_from_env(control.env)
-    @appname ||= NewRelic::Agent.config[:app_name][0] || control.env || 'development'
-    @license_key ||= NewRelic::Agent.config[:license_key]
-    @api_key ||= NewRelic::Agent.config[:api_key]
-
-    setup_logging(control.env)
-  end
-
-  def load_yaml_from_env(env)
-    yaml = NewRelic::Agent::Configuration::YamlSource.new(NewRelic::Agent.config[:config_path], env)
-    if yaml.failed?
-      messages = yaml.failures.flatten.map(&:to_s).join("\n")
-      raise NewRelic::Cli::Command::CommandFailure.new("Error in loading newrelic.yml.\n#{messages}")
-    end
-
-    NewRelic::Agent.config.replace_or_add_config(yaml)
-  end
-
-  def setup_logging(env)
-    NewRelic::Agent.logger = NewRelic::Agent::AgentLogger.new
-    NewRelic::Agent.logger.info("Running Capistrano from '#{env}' environment for application '#{@appname}'")
-  end
-
-  # Run the Deployment upload in New Relic via Active Resource.
-  # Will possibly print errors and exit the VM
-  def run
-    msg = <<~TEXT
-      DEPRECATED: The `newrelic deployments` command will be removed in v10.0.0. Learn more about the alternate options: https://docs.newrelic.com/docs/change-tracking/change-tracking-introduction/
-    TEXT
-    NewRelic::Agent.logger.log_once(:warn, 'newrelic_deployments'.to_sym, msg)
-    warn msg
-
-    begin
-      @description = nil if @description && @description.strip.empty?
-
-      if @license_key.nil? || @license_key.empty?
-        raise "license_key not set in newrelic.yml for #{control.env}. api_key also required to use New Relic REST API v2"
-      end
-
-      if !api_v1? && (@revision.nil? || @revision.empty?)
-        raise 'revision required when using New Relic REST API v2 with api_key. Pass in revision using: -r, --revision=REV'
-      end
-
-      request = if api_v1?
-        uri = '/deployments.xml'
-        create_request(uri, {'x-license-key' => @license_key}, 'application/octet-stream').tap do |req|
-          set_params_v1(req)
-        end
-      else
-        uri = "/v2/applications/#{application_id}/deployments.json"
-        create_request(uri, {'Api-Key' => @api_key}, 'application/json').tap do |req|
-          set_params_v2(req)
-        end
-      end
-
-      http = ::NewRelic::Agent::NewRelicService.new(nil, control.api_server).http_connection
-      response = http.request(request)
-
-      if response.is_a?(Net::HTTPSuccess)
-        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::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::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::Cli::Command::CommandFailure.new(e.to_s)
-    end
-  end
-
-  def api_v1?
-    @api_key.nil? || @api_key.empty?
-  end
-
-  private
-
-  def create_request(uri, headers, content_type)
-    Net::HTTP::Post.new(uri, headers).tap do |req|
-      req.content_type = content_type
-    end
-  end
-
-  def application_id
-    return @application_id if @application_id
-
-    # Need to connect to collector to acquire application id from the connect response
-    # but set monitor_mode false because we don't want to actually report anything
-    begin
-      NewRelic::Agent.manual_start(monitor_mode: false)
-      NewRelic::Agent.agent.connect_to_server
-      @application_id = NewRelic::Agent.config[:primary_application_id]
-    ensure
-      NewRelic::Agent.shutdown
-    end
-  end
-
-  def set_params_v1(request)
-    params = {
-      :application_id => @appname,
-      :host => NewRelic::Agent::Hostname.get,
-      :description => @description,
-      :user => @user,
-      :revision => @revision,
-      :changelog => @changelog
-    }.each_with_object({}) do |(k, v), h|
-      h["deployment[#{k}]"] = v unless v.nil? || v == ''
-    end
-    request.set_form_data(params)
-  end
-
-  def set_params_v2(request)
-    request.body = {
-      'deployment' => {
-        :description => @description,
-        :user => @user,
-        :revision => @revision,
-        :changelog => @changelog
-      }
-    }.to_json
-  end
-
-  def options
-    OptionParser.new(%Q(Usage: #{$0} #{self.class.command} [OPTIONS] ["description"] ), 40) do |o|
-      o.separator('OPTIONS:')
-      o.on('-a', '--appname=NAME', String,
-        'Set the application name.',
-        'Default is app_name setting in newrelic.yml. Available only when using API v1.') { |e| @appname = e }
-      o.on('-i', '--appid=ID', String,
-        'Set the application ID',
-        'If not provided, will connect to the New Relic collector to get it') { |i| @application_id = i }
-      o.on('-e', '--environment=name', String,
-        'Override the (RAILS|RUBY|RACK)_ENV setting',
-        "currently: #{control.env}") { |e| @environment = e }
-      o.on('-u', '--user=USER', String,
-        'Specify the user deploying, for information only',
-        "Default: #{@user || '<none>'}") { |u| @user = u }
-      o.on('-r', '--revision=REV', String,
-        'Specify the revision being deployed. Required when using New Relic REST API v2') { |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?
-    end
-  end
-end

data/lib/new_relic/recipes/capistrano3.rb

@@ -1,23 +0,0 @@
-# This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
-# frozen_string_literal: true
-
-require 'capistrano/framework'
-require_relative 'helpers/send_deployment'
-
-namespace :newrelic do
-  include SendDeployment
-  # notifies New Relic of a deployment
-  desc 'Record a deployment in New Relic (newrelic.com)'
-  task :notice_deployment do
-    if fetch(:newrelic_role)
-      on roles(fetch(:newrelic_role)) do
-        send_deployment_notification_to_newrelic
-      end
-    else
-      run_locally do
-        send_deployment_notification_to_newrelic
-      end
-    end
-  end
-end

data/lib/new_relic/recipes/capistrano_legacy.rb

@@ -1,95 +0,0 @@
-# This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
-# frozen_string_literal: true
-
-make_notify_task = proc 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 --no-pager 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/recipes/helpers/send_deployment.rb

@@ -1,70 +0,0 @@
-# This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
-# frozen_string_literal: true
-
-module SendDeployment
-  def send_deployment_notification_to_newrelic
-    require 'new_relic/cli/command'
-    debug('Uploading deployment to New Relic')
-    NewRelic::Cli::Deployments.new(deploy_options).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
-
-  private
-
-  def deploy_options
-    {
-      :environment => fetch_environment,
-      :revision => fetch_rev,
-      :changelog => fetch_changelog,
-      :description => fetch(:newrelic_desc),
-      :appname => fetch(:newrelic_appname),
-      :user => fetch(:newrelic_user),
-      :license_key => fetch(:newrelic_license_key)
-    }
-  end
-
-  def fetch_changelog
-    newrelic_changelog = fetch(:newrelic_changelog)
-    has_scm? && !newrelic_changelog ? lookup_changelog : newrelic_changelog
-  end
-
-  def fetch_environment
-    fetch(:newrelic_rails_env, fetch(:rack_env, fetch(:rails_env, fetch(:stage, 'production'))))
-  end
-
-  def fetch_rev
-    newrelic_rev = fetch(:newrelic_revision)
-    has_scm? && !newrelic_rev ? fetch(:current_revision) : newrelic_rev
-  end
-
-  def has_scm?
-    has_scm_from_plugin? || has_scm_from_config?
-  end
-
-  def has_scm_from_config?
-    defined?(scm) && !scm.nil? && scm != :none
-  end
-
-  def has_scm_from_plugin?
-    respond_to?(:scm_plugin_installed?) && scm_plugin_installed?
-  end
-
-  def lookup_changelog
-    previous_revision = fetch(:previous_revision)
-    current_revision = fetch(:current_revision)
-    return unless current_revision && previous_revision
-
-    debug('Retrieving changelog for New Relic Deployment details')
-
-    if Rake::Task.task_defined?('git:check')
-      log_command = "git --no-pager 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.rb

@@ -1,24 +0,0 @@
-# This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
-# frozen_string_literal: true
-
-# When installed as a plugin, this is loaded automatically.
-#
-# When installed as a gem, you need to add
-#  require 'new_relic/recipes'
-# to deploy.rb
-#
-# 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
-#
-
-require 'capistrano/version'
-
-if defined?(Capistrano::VERSION) && Capistrano::VERSION.to_s.split('.').first.to_i >= 3
-  require 'new_relic/recipes/capistrano3'
-else
-  require 'new_relic/recipes/capistrano_legacy'
-end

data/recipes/newrelic.rb

@@ -1,10 +0,0 @@
-# This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
-# frozen_string_literal: true
-
-# The capistrano recipes in plugins are automatically
-# loaded from here.  From gems, they are available from
-# the lib directory.  We have to make them available from
-# both locations
-
-require File.join(File.dirname(__FILE__), '..', 'lib', 'new_relic', 'recipes')