newrelic_rpm 6.3.0.355 → 9.2.0

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

@@ -1,23 +1,22 @@
-# 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.
+# 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 'rexml/document'
 require 'new_relic/agent/hostname'
 
 # We need to use the Control object but we don't want to load
-# the rails/merb environment.  The defined? clause is so that
+# 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
   attr_reader :control
-  def self.command; "deployments"; end
+  def self.command; 'deployments'; end
 
   # Initialize the deployment uploader with command line args.
   # Use -h to see options.
@@ -28,19 +27,21 @@ class NewRelic::Cli::Deployments < NewRelic::Cli::Command
   #
   # Will throw CommandFailed exception if there's any error.
   #
-  def initialize command_line_args
+  def initialize(command_line_args)
     @control = NewRelic::Control.instance
     @environment = nil
-    @changelog   = nil
-    @user        = nil
+    @changelog = nil
+    @user = nil
     super(command_line_args)
-    @description ||= @leftover && @leftover.join(" ")
+    # 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_names[0] || control.env || 'development'
+    @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
@@ -65,35 +66,34 @@ class NewRelic::Cli::Deployments < NewRelic::Cli::Command
   def run
     begin
       @description = nil if @description && @description.strip.empty?
-      create_params = {}
-      {
-            :application_id => @appname,
-            :host => NewRelic::Agent::Hostname.get,
-            :description => @description,
-            :user => @user,
-            :revision => @revision,
-            :changelog => @changelog
-      }.each do |k, v|
-        create_params["deployment[#{k}]"] = v unless v.nil? || v == ''
-      end
-      http = ::NewRelic::Agent::NewRelicService.new(nil, control.api_server).http_connection
-
-      uri = "/deployments.xml"
 
       if @license_key.nil? || @license_key.empty?
-        raise "license_key was not set in newrelic.yml for #{control.env}"
+        raise "license_key not set in newrelic.yml for #{control.env}. api_key also required to use New Relic REST API v2"
       end
-      request = Net::HTTP::Post.new(uri, {'x-license-key' => @license_key})
-      request.content_type = "application/octet-stream"
 
-      request.set_form_data(create_params)
+      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 })"
+      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
+        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
@@ -103,35 +103,85 @@ class NewRelic::Cli::Deployments < NewRelic::Cli::Command
     rescue NewRelic::Cli::Command::CommandFailure
       raise
     rescue => e
-      err "Unexpected error attempting to connect to #{control.api_server}"
-      info "#{e}: #{e.backtrace.join("\n   ")}"
+      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 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") { | e | @appname = e }
-      o.on("-e", "--environment=name", String,
-               "Override the (RAILS|MERB|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") { | 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?
+  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/cli/commands/install.rb

@@ -1,16 +1,15 @@
-# 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.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 require 'fileutils'
 require 'new_relic/version'
 require 'erb'
 
 class NewRelic::Cli::Install < NewRelic::Cli::Command
+  NO_LICENSE_KEY = '<PASTE LICENSE KEY HERE>'
 
-  NO_LICENSE_KEY = "<PASTE LICENSE KEY HERE>"
-
-  def self.command; "install"; end
+  def self.command; 'install'; end
 
   # Use -h to see options.
   # When command_line_args is a hash, we are invoking directly and
@@ -21,50 +20,50 @@ class NewRelic::Cli::Install < NewRelic::Cli::Command
   # Will throw CommandFailed exception if there's any error.
   #
   attr_reader :dest_dir, :license_key, :generated_for_user, :quiet, :src_file, :app_name
-  def initialize command_line_args={}
+  def initialize(command_line_args = {})
     @dest_dir = nil
-    super command_line_args
+    super(command_line_args)
     if @dest_dir.nil?
       # Install a newrelic.yml file into the local config directory.
-      if File.directory? "config"
-        @dest_dir = "config"
+      if File.directory?('config')
+        @dest_dir = 'config'
       else
-        @dest_dir = "."
+        @dest_dir = '.'
       end
     end
     @license_key ||= NO_LICENSE_KEY
-    @app_name ||= @leftover.join(" ")
+    @app_name ||= @leftover.join(' ')
     @agent_version = NewRelic::VERSION::STRING
-    raise CommandFailure.new("Application name required.", @options) unless @app_name && @app_name.size > 0
+    raise CommandFailure.new('Application name required.', @options) unless @app_name && @app_name.size > 0
   end
 
   def run
-    dest_file = File.expand_path(@dest_dir + "/newrelic.yml")
-    if File.exist?(dest_file)
-      raise NewRelic::Cli::Command::CommandFailure, "newrelic.yml file already exists.  Move it out of the way."
+    dest_file = File.expand_path(@dest_dir + '/newrelic.yml')
+    if File.exist?(dest_file) && !@force
+      raise NewRelic::Cli::Command::CommandFailure, 'newrelic.yml file already exists.  Use --force flag to overwrite.'
     end
-    File.open(dest_file, 'w') { | out | out.puts(content) }
 
-    puts <<-EOF unless quiet
+    File.open(dest_file, 'w') { |out| out.puts(content) }
 
-Installed a default configuration file at
-#{dest_file}.
-    EOF
-    puts <<-EOF unless quiet || @license_key != NO_LICENSE_KEY
+    puts <<~EOF unless quiet
 
-To monitor your application in production mode, sign up for an account
-at www.newrelic.com, and replace the newrelic.yml file with the one
-you receive upon registration.
+      Installed a default configuration file at
+      #{dest_file}.
     EOF
-    puts <<-EOF unless quiet
+    puts <<~EOF unless quiet || @license_key != NO_LICENSE_KEY
 
-Visit support.newrelic.com if you are experiencing installation issues.
+      To monitor your application in production mode, sign up for an account
+      at www.newrelic.com, and replace the newrelic.yml file with the one
+      you receive upon registration.
     EOF
+    puts <<~EOF unless quiet
 
+      Visit support.newrelic.com if you are experiencing installation issues.
+    EOF
   end
 
   def content
-    @src_file ||= File.expand_path(File.join(File.dirname(__FILE__),"..","..","..","..","newrelic.yml"))
+    @src_file ||= File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', '..', 'newrelic.yml'))
     template = File.read(@src_file)
     ERB.new(template).result(binding)
   end
@@ -72,14 +71,13 @@ Visit support.newrelic.com if you are experiencing installation issues.
   private
 
   def options
-    OptionParser.new "Usage: #{$0} #{self.class.command} [ OPTIONS] 'application name'", 40 do |o|
-      o.on("-l", "--license_key=NAME", String,
-             "Use the given license key") { | e | @license_key = e }
-      o.on("-d", "--destdir=name", String,
-               "Write the newrelic.yml to the given directory, default is '.'") { | e | @dest_dir = e }
-      yield o if block_given?
+    OptionParser.new("Usage: #{$0} #{self.class.command} [ OPTIONS] 'application name'", 40) do |o|
+      o.on('-f', '--force', 'Overwrite newrelic.yml if it exists') { |e| @force = true }
+      o.on('-l', '--license_key=NAME', String,
+        'Use the given license key') { |e| @license_key = e }
+      o.on('-d', '--destdir=name', String,
+        "Write the newrelic.yml to the given directory, default is '.'") { |e| @dest_dir = e }
+      yield(o) if block_given?
     end
   end
-
-
 end

data/lib/new_relic/coerce.rb

@@ -1,47 +1,51 @@
-# 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.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 module NewRelic
-  # We really don't want to send bad values to the collector, and it doesn't
-  # accept types like Rational that have occasionally slipped into our data.
-  #
-  # These methods are intended to safely coerce things into the form we want,
-  # to provide documentation of expected types on to_collector_array methods,
-  # and to log failures if totally invalid data gets into outgoing data
   module Coerce
     module_function
 
-    def int(value, context=nil)
+    # We really don't want to send bad values to the collector, and it doesn't
+    # accept types like Rational that have occasionally slipped into our data.
+    #
+    # These non-bang methods are intended to safely coerce things into the form we want,
+    # to provide documentation of expected types on to_collector_array methods,
+    # and to log failures if totally invalid data gets into outgoing data
+
+    def int(value, context = nil)
       Integer(value)
     rescue => error
       log_failure(value, Integer, context, error)
       0
     end
 
-    def int_or_nil(value, context=nil)
+    def int_or_nil(value, context = nil)
       return nil if value.nil?
+
       Integer(value)
     rescue => error
       log_failure(value, Integer, context, error)
       nil
     end
 
-    def float(value, context=nil)
+    def float(value, context = nil)
       result = Float(value)
       raise "Value #{result.inspect} is not finite." unless result.finite?
+
       result
     rescue => error
       log_failure(value, Float, context, error)
       0.0
     end
 
-    def string(value, context=nil)
+    def string(value, context = nil)
       return value if value.nil?
+
       String(value)
     rescue => error
       log_failure(value.class, String, context, error)
-      ""
+      EMPTY_STR
     end
 
     def scalar(val)
@@ -51,8 +55,6 @@ module NewRelic
       when Float
         if val.finite?
           val
-        else
-          nil
         end
       when Symbol
         val.to_s
@@ -61,6 +63,31 @@ module NewRelic
       end
     end
 
+    def int!(value)
+      return nil unless value_or_nil(value)
+
+      Integer(value)
+    end
+
+    # Use when you plan to perform a boolean check using the integer 1
+    # for true and the integer 0 for false
+    # String values will be converted to 0
+    def boolean_int!(value)
+      value.to_i
+    end
+
+    def float!(value, precision = NewRelic::PRIORITY_PRECISION)
+      return nil unless value_or_nil(value)
+
+      value.to_f.round(precision)
+    end
+
+    def value_or_nil(value)
+      return nil if value.nil? || (value.respond_to?(:empty?) && value.empty?)
+
+      value
+    end
+
     def log_failure(value, type, context, error)
       msg = "Unable to convert '#{value}' to #{type}"
       msg += " in context '#{context}'" if context

data/lib/new_relic/collection_helper.rb

@@ -1,61 +1,63 @@
-# 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.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 module NewRelic
   module CollectionHelper
-  DEFAULT_TRUNCATION_SIZE=16 * 1024
-  DEFAULT_ARRAY_TRUNCATION_SIZE=128
-  # Transform parameter hash into a hash whose values are strictly
-  # strings
-  def normalize_params(params)
-    case params
-      when Hash
-        # optimize for empty hash since that is often what this is called with.
-        return params if params.empty?
-        new_params = {}
-        params.each do | key, value |
-          new_params[truncate(normalize_params(key),64)] = normalize_params(value)
-        end
-        new_params
-      when Symbol, FalseClass, TrueClass, nil
-        params
-      when Numeric
-        truncate(params.to_s)
-      when String
-        truncate(params)
-      when Array
-        params.first(DEFAULT_ARRAY_TRUNCATION_SIZE).map{|item| normalize_params(item)}
-    else
-      truncate(flatten(params))
+    DEFAULT_TRUNCATION_SIZE = 16 * 1024
+    DEFAULT_ARRAY_TRUNCATION_SIZE = 128
+    # Transform parameter hash into a hash whose values are strictly
+    # strings
+    def normalize_params(params)
+      case params
+        when Hash
+          # Optimize for empty hash since that is often what this is called with.
+          return params if params.empty?
+
+          new_params = {}
+          params.each do |key, value|
+            new_params[truncate(normalize_params(key), 64)] = normalize_params(value)
+          end
+          new_params
+        when Symbol, FalseClass, TrueClass, nil
+          params
+        when Numeric
+          truncate(params.to_s)
+        when String
+          truncate(params)
+        when Array
+          params.first(DEFAULT_ARRAY_TRUNCATION_SIZE).map { |item| normalize_params(item) }
+        else
+          truncate(flatten(params))
+      end
     end
-  end
 
-  private
+    private
 
-  # Convert any kind of object to a short string.
-  def flatten(object)
-    case object
-      when nil then ''
-      when object.instance_of?(String) then object
-      when String then String.new(object)  # convert string subclasses to strings
-      else "#<#{object.class.to_s}>"
+    # Convert any kind of object to a short string.
+    def flatten(object)
+      case object
+        when nil then ''
+        when object.instance_of?(String) then object
+        when String then String.new(object) # convert string subclasses to strings
+        else +"#<#{object.class}>"
+      end
     end
-  end
-  def truncate(string, len=DEFAULT_TRUNCATION_SIZE)
-    case string
-    when Symbol then string
-    when nil then ""
-    when String
-      real_string = flatten(string)
-      if real_string.size > len
-        real_string = real_string.slice(0...len)
-        real_string << "..."
+
+    def truncate(string, len = DEFAULT_TRUNCATION_SIZE)
+      case string
+      when Symbol then string
+      when nil then EMPTY_STR
+      when String
+        real_string = flatten(string)
+        if real_string.size > len
+          real_string = real_string.slice(0...len)
+          real_string << '...'
+        end
+        real_string
+      else
+        truncate(flatten(string), len)
       end
-      real_string
-    else
-      truncate(flatten(string), len)
     end
   end
-  end
 end

data/lib/new_relic/constants.rb

@@ -0,0 +1,38 @@
+# 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
+  PRIORITY_PRECISION = 6
+
+  EMPTY_ARRAY = [].freeze
+  EMPTY_HASH = {}.freeze
+  EMPTY_STR = ''
+
+  HTTP = 'HTTP'
+  HTTPS = 'HTTPS'
+  UNKNOWN = 'Unknown'
+
+  FORMAT_NON_RACK = 0
+  FORMAT_RACK = 1
+
+  NEWRELIC_KEY = 'newrelic'
+  CANDIDATE_NEWRELIC_KEYS = [
+    NEWRELIC_KEY,
+    'NEWRELIC',
+    'NewRelic',
+    'Newrelic'
+  ].freeze
+
+  TRACEPARENT_KEY = 'traceparent'
+  TRACESTATE_KEY = 'tracestate'
+
+  STANDARD_OUT = 'STDOUT'
+
+  HTTP_TRACEPARENT_KEY = "HTTP_#{TRACEPARENT_KEY.upcase}"
+  HTTP_TRACESTATE_KEY = "HTTP_#{TRACESTATE_KEY.upcase}"
+  HTTP_NEWRELIC_KEY = "HTTP_#{NEWRELIC_KEY.upcase}"
+
+  CONNECT_RETRY_PERIODS = [15, 15, 30, 60, 120, 300]
+  MAX_RETRY_PERIOD = 300
+end

data/lib/new_relic/control/class_methods.rb

@@ -1,6 +1,6 @@
-# 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.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 module NewRelic
   class Control
@@ -9,7 +9,7 @@ module NewRelic
     module ClassMethods
       # Access the Control singleton, lazy initialized.  Default will instantiate a new
       # instance or pass false to defer
-      def instance(create=true)
+      def instance(create = true)
         @instance ||= create && new_instance
       end
 
@@ -35,8 +35,8 @@ module NewRelic
 
       # nb this does not 'load test' the framework, it loads the 'test framework'
       def load_test_framework
-        config = File.expand_path(File.join('..','..','..','..', "test","config","newrelic.yml"), __FILE__)
-        require "config/test_control"
+        config = File.expand_path(File.join('..', '..', '..', '..', 'test', 'config', 'newrelic.yml'), __FILE__)
+        require 'config/test_control'
         NewRelic::Control::Frameworks::Test.new(local_env, config)
       end
 
@@ -54,7 +54,7 @@ module NewRelic
 
       # The root directory for the plugin or gem
       def newrelic_root
-        File.expand_path(File.join("..", "..", "..", ".."), __FILE__)
+        File.expand_path(File.join('..', '..', '..', '..'), __FILE__)
       end
 
       def camelize(snake_case_name)

data/lib/new_relic/control/frameworks/external.rb

@@ -1,6 +1,6 @@
-# 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.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 require 'new_relic/control/frameworks/ruby'
 module NewRelic
@@ -11,7 +11,7 @@ module NewRelic
       # out specifically because in this context we are not monitoring
       # the running process, but actually external things.
       class External < NewRelic::Control::Frameworks::Ruby
-        def init_config(options={})
+        def init_config(options = {})
           super
         end
       end