newrelic_rpm 8.6.0 → 8.7.0

data/lib/new_relic/agent/instrumentation/authlogic.rb

@@ -13,6 +13,16 @@ DependencyDetection.defer do
 
   executes do
     ::NewRelic::Agent.logger.info 'Installing Authlogic instrumentation'
+    deprecation_msg = 'The instrumentation for Authlogic is deprecated. ' \
+      'It will be removed in version 9.0.0.' \
+
+    ::NewRelic::Agent.logger.log_once(
+      :warn,
+      :deprecated_authlogic,
+      deprecation_msg
+    )
+
+    ::NewRelic::Agent.record_metric("Supportability/Deprecated/Authlogic", 1)
   end
 
   executes do

data/lib/new_relic/agent/instrumentation/data_mapper.rb

@@ -15,6 +15,18 @@ DependencyDetection.defer do
   executes do
     ::NewRelic::Agent.logger.info 'Installing DataMapper instrumentation'
     require 'new_relic/agent/datastores/metric_helper'
+
+    deprecation_msg = 'The instrumentation for DataMapper is deprecated. ' \
+     'It will be removed in version 9.0.0.' \
+     'Visit https://docs.newrelic.com/docs/apm/agents/ruby-agent/getting-started/ruby-agent-requirements-supported-frameworks ' \
+     'to learn about supported gems.'
+
+    ::NewRelic::Agent.logger.log_once(
+      :warn,
+      :deprecated_datamapper,
+      deprecation_msg
+    )
+    ::NewRelic::Agent.record_metric("Supportability/Deprecated/DataMapper", 1)
   end
 
   executes do

data/lib/new_relic/agent/instrumentation/delayed_job_instrumentation.rb

@@ -93,4 +93,23 @@ DependencyDetection.defer do
       chain_instrument ::NewRelic::Agent::Instrumentation::DelayedJob::Chain
     end
   end
+
+  executes do
+    next unless delayed_job_version < Gem::Version.new('4.1.0')
+    deprecation_msg = 'Instrumentation for DelayedJob versions below 4.1.0 is deprecated.' \
+      'It will stop being monitored in version 9.0.0. ' \
+      'Please upgrade your DelayedJob version to continue receiving full support. ' \
+
+    ::NewRelic::Agent.logger.log_once(
+      :warn,
+      :deprecated_delayed_job_version,
+      deprecation_msg
+    )
+
+    ::NewRelic::Agent.record_metric("Supportability/Deprecated/DelayedJob", 1)
+  end
+
+  def delayed_job_version
+    Gem.loaded_specs['delayed_job'].version if Gem.loaded_specs['delayed_job']
+  end
 end

data/lib/new_relic/agent/instrumentation/rack/helpers.rb

@@ -20,6 +20,8 @@ module NewRelic::Agent::Instrumentation
       return false unless defined? ::Puma::Const::PUMA_VERSION
 
       version = Gem::Version.new(::Puma::Const::PUMA_VERSION)
+      # TODO: MAJOR VERSION - update min_version to 3.9.0
+      # min_version = Gem::Version.new('3.9.0')
       min_version = Gem::Version.new('2.12.0')
       version >= min_version
     end

data/lib/new_relic/agent/instrumentation/rainbows_instrumentation.rb

@@ -12,6 +12,17 @@ DependencyDetection.defer do
   executes do
     ::NewRelic::Agent.logger.info 'Installing Rainbows instrumentation'
     ::NewRelic::Agent.logger.info 'Detected Rainbows, please see additional documentation: https://newrelic.com/docs/troubleshooting/im-using-unicorn-and-i-dont-see-any-data'
+
+    deprecation_msg = 'The dispatcher rainbows is deprecated. It will be removed ' \
+     'in version 9.0.0. Please use a supported dispatcher instead. ' \
+     'Visit https://docs.newrelic.com/docs/apm/agents/ruby-agent/getting-started/ruby-agent-requirements-supported-frameworks for options.'
+
+    ::NewRelic::Agent.logger.log_once(
+      :warn,
+      :deprecated_rainbows_dispatcher,
+      deprecation_msg
+    )
+    ::NewRelic::Agent.record_metric("Supportability/Deprecated/Rainbows", 1)
   end
 
   executes do

data/lib/new_relic/agent/instrumentation/sidekiq.rb

@@ -99,4 +99,19 @@ DependencyDetection.defer do
       end
     end
   end
+
+  executes do
+    next unless Gem::Version.new(Sidekiq::VERSION) < Gem::Version.new('5.0.0')
+    deprecation_msg = 'Instrumentation for Sidekiq versions below 5.0.0 is deprecated.' \
+      'They will stop being monitored in version 9.0.0. ' \
+      'Please upgrade your Sidekiq version to continue receiving full support. '
+
+    ::NewRelic::Agent.logger.log_once(
+      :warn,
+      :deprecated_sidekiq_version,
+      deprecation_msg
+    )
+
+    ::NewRelic::Agent.record_metric("Supportability/Deprecated/Sidekiq", 1)
+  end
 end

data/lib/new_relic/agent/instrumentation/sinatra.rb

@@ -32,18 +32,28 @@ DependencyDetection.defer do
   end
 
   executes do
-    if Sinatra::Base.respond_to?(:build)
-      # These requires are inside an executes block because they require rack, and
-      # we can't be sure that rack is available when this file is first required.
-      require 'new_relic/rack/agent_hooks'
-      require 'new_relic/rack/browser_monitoring'
-      if use_prepend?
-        prepend_instrument ::Sinatra::Base.singleton_class, NewRelic::Agent::Instrumentation::Sinatra::Build::Prepend
-      else
-        chain_instrument NewRelic::Agent::Instrumentation::Sinatra::Build::Chain
-      end
+    # These requires are inside an executes block because they require rack, and
+    # we can't be sure that rack is available when this file is first required.
+    require 'new_relic/rack/agent_hooks'
+    require 'new_relic/rack/browser_monitoring'
+    if use_prepend?
+      prepend_instrument ::Sinatra::Base.singleton_class, NewRelic::Agent::Instrumentation::Sinatra::Build::Prepend
     else
-      ::NewRelic::Agent.logger.info("Skipping auto-injection of middleware for Sinatra - requires Sinatra 1.2.1+")
+      chain_instrument NewRelic::Agent::Instrumentation::Sinatra::Build::Chain
     end
   end
+
+  executes do
+    next unless Gem::Version.new(Sinatra::VERSION) < Gem::Version.new('2.0.0')
+    deprecation_msg = 'The Ruby Agent is dropping support for Sinatra versions below 2.0.0 ' \
+      'in version 9.0.0. Please upgrade your Sinatra version to continue receiving full compatibility. ' \
+
+    ::NewRelic::Agent.logger.log_once(
+      :warn,
+      :deprecated_sinatra_version,
+      deprecation_msg
+    )
+
+    ::NewRelic::Agent.record_metric("Supportability/Deprecated/Sinatra", 1)
+  end
 end

data/lib/new_relic/agent/instrumentation/sunspot.rb

@@ -11,6 +11,16 @@ DependencyDetection.defer do
 
   executes do
     ::NewRelic::Agent.logger.info 'Installing Rails Sunspot instrumentation'
+    deprecation_msg = 'The instrumentation for Sunspot is deprecated.' \
+      ' It will be removed in version 9.0.0.' \
+
+    ::NewRelic::Agent.logger.log_once(
+      :warn,
+      :deprecated_sunspot,
+      deprecation_msg
+    )
+
+    ::NewRelic::Agent.record_metric("Supportability/Deprecated/Sunspot", 1)
   end
 
   executes do

data/lib/new_relic/agent/instrumentation/thread/chain.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+
+require_relative 'instrumentation'
+
+module NewRelic::Agent::Instrumentation
+  module MonitoredThread
+    module Chain
+      def self.instrument!
+        ::Thread.class_eval do
+          include NewRelic::Agent::Instrumentation::MonitoredThread
+
+          alias_method :initialize_without_new_relic, :initialize
+
+          def initialize(*args, &block)
+            traced_block = add_thread_tracing(*args, &block)
+            initialize_with_newrelic_tracing { initialize_without_new_relic(*args, &traced_block) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/thread/instrumentation.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+
+module NewRelic
+  module Agent
+    module Instrumentation
+      module MonitoredThread
+        attr_reader :nr_parent_thread_id
+
+        def initialize_with_newrelic_tracing
+          @nr_parent_thread_id = ::Thread.current.object_id
+          yield
+        end
+
+        def add_thread_tracing(*args, &block)
+          return block if skip_tracing?
+          NewRelic::Agent::Tracer.thread_block_with_current_transaction(*args, &block)
+        end
+
+        def skip_tracing?
+          !NewRelic::Agent.config[:'instrumentation.thread.tracing']
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/thread/prepend.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+
+require_relative 'instrumentation'
+
+module NewRelic
+  module Agent
+    module Instrumentation
+      module MonitoredThread
+        module Prepend
+          include NewRelic::Agent::Instrumentation::MonitoredThread
+
+          def initialize(*args, &block)
+            traced_block = add_thread_tracing(*args, &block)
+            initialize_with_newrelic_tracing { super(*args, &traced_block) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/thread.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+
+require_relative 'thread/chain'
+require_relative 'thread/prepend'
+
+DependencyDetection.defer do
+  named :thread
+
+  executes do
+    ::NewRelic::Agent.logger.info 'Installing Thread Instrumentation'
+
+    if use_prepend?
+      prepend_instrument ::Thread, ::NewRelic::Agent::Instrumentation::MonitoredThread::Prepend
+    else
+      chain_instrument ::NewRelic::Agent::Instrumentation::MonitoredThread::Chain
+    end
+  end
+end

data/lib/new_relic/agent/pipe_service.rb

@@ -10,8 +10,7 @@ module NewRelic
 
       def initialize(channel_id)
         @channel_id = channel_id
-        @collector = NewRelic::Control::Server.new(:name => 'parent',
-          :port => 0)
+        @collector = NewRelic::Control::Server.new({name: 'parent', port: 0})
         @pipe = NewRelic::Agent::PipeChannelManager.channels[@channel_id]
         if @pipe && @pipe.parent_pid != $$
           @pipe.after_fork_in_child

data/lib/new_relic/agent/stats.rb

@@ -4,6 +4,8 @@
 module NewRelic
   module Agent
     class Stats
+      SKIP_MARSHALLING = [:@lock]
+
       attr_accessor :call_count
       attr_accessor :min_call_time
       attr_accessor :max_call_time
@@ -12,6 +14,7 @@ module NewRelic
       attr_accessor :sum_of_squares
 
       def initialize
+        @lock = Mutex.new
         reset
       end
 
@@ -34,12 +37,14 @@ module NewRelic
       end
 
       def merge!(other)
-        @min_call_time = other.min_call_time if min_time_less?(other)
-        @max_call_time = other.max_call_time if other.max_call_time > max_call_time
-        @total_call_time += other.total_call_time
-        @total_exclusive_time += other.total_exclusive_time
-        @sum_of_squares += other.sum_of_squares
-        @call_count += other.call_count
+        @lock.synchronize do
+          @min_call_time = other.min_call_time if min_time_less?(other)
+          @max_call_time = other.max_call_time if other.max_call_time > max_call_time
+          @total_call_time += other.total_call_time
+          @total_exclusive_time += other.total_exclusive_time
+          @sum_of_squares += other.sum_of_squares
+          @call_count += other.call_count
+        end
         self
       end
 
@@ -78,13 +83,15 @@ module NewRelic
       # will aggregate all data points collected over a specified period and upload
       # its data to the NewRelic server
       def record_data_point(value, exclusive_time = value)
-        @call_count += 1
-        @total_call_time += value
-        @min_call_time = value if value < @min_call_time || @call_count == 1
-        @max_call_time = value if value > @max_call_time
-        @total_exclusive_time += exclusive_time
-
-        @sum_of_squares += (value * value)
+        @lock.synchronize do
+          @call_count += 1
+          @total_call_time += value
+          @min_call_time = value if value < @min_call_time || @call_count == 1
+          @max_call_time = value if value > @max_call_time
+          @total_exclusive_time += exclusive_time
+
+          @sum_of_squares += (value * value)
+        end
         self
       end
 
@@ -92,7 +99,7 @@ module NewRelic
 
       # increments the call_count by one
       def increment_count(value = 1)
-        @call_count += value
+        @lock.synchronize { @call_count += value }
       end
 
       # Concerned about implicit usage of inspect relying on stats format, so
@@ -122,17 +129,35 @@ module NewRelic
       alias_method :apdex_f, :total_exclusive_time
 
       def record_apdex(bucket, apdex_t)
-        case bucket
-        when :apdex_s then @call_count += 1
-        when :apdex_t then @total_call_time += 1
-        when :apdex_f then @total_exclusive_time += 1
+        @lock.synchronize do
+          case bucket
+          when :apdex_s then @call_count += 1
+          when :apdex_t then @total_call_time += 1
+          when :apdex_f then @total_exclusive_time += 1
+          end
+          if apdex_t
+            @min_call_time = apdex_t
+            @max_call_time = apdex_t
+          else
+            ::NewRelic::Agent.logger.warn("Attempted to set apdex_t to #{apdex_t.inspect}, backtrace = #{caller.join("\n")}")
+          end
         end
-        if apdex_t
-          @min_call_time = apdex_t
-          @max_call_time = apdex_t
-        else
-          ::NewRelic::Agent.logger.warn("Attempted to set apdex_t to #{apdex_t.inspect}, backtrace = #{caller.join("\n")}")
+      end
+
+      # Override marshalling methods to exclude @lock from being included in marshalled data
+      def marshal_dump
+        instance_variables.each_with_object({}) do |name, instance_copy|
+          next if SKIP_MARSHALLING.include?(name)
+          instance_copy[name] = instance_variable_get(name)
+        end
+      end
+
+      def marshal_load(marshalled_data)
+        marshalled_data.each do |name, value|
+          instance_variable_set(name, value) unless SKIP_MARSHALLING.include?(name)
         end
+        # since the lock is excluded when marshalling, create a new lock when loading marshalled data
+        @lock = Mutex.new
       end
 
       protected

data/lib/new_relic/agent/tracer.rb

@@ -405,6 +405,19 @@ module NewRelic
 
         alias_method :tl_clear, :clear_state
 
+        def thread_block_with_current_transaction(*args, &block)
+          current_txn = ::Thread.current[:newrelic_tracer_state].current_transaction if ::Thread.current[:newrelic_tracer_state]
+          Proc.new do
+            begin
+              NewRelic::Agent::Tracer.state.current_transaction = current_txn
+              segment = NewRelic::Agent::Tracer.start_segment(name: "Ruby/Thread/#{::Thread.current.object_id}")
+              block.call(*args) if block.respond_to?(:call)
+            ensure
+              segment.finish if segment
+            end
+          end
+        end
+
         private
 
         def start_and_add_segment segment, parent = nil
@@ -445,7 +458,7 @@ module NewRelic
         end
 
         # Current transaction stack
-        attr_reader :current_transaction
+        attr_accessor :current_transaction
 
         # Execution tracing on current thread
         attr_accessor :untraced

data/lib/new_relic/agent/transaction/abstract_segment.rb

@@ -20,13 +20,14 @@ module NewRelic
         # after its parent. We will use the optimized exclusive duration
         # calculation in all other cases.
         #
-        attr_reader :start_time, :end_time, :duration, :exclusive_duration, :guid
+        attr_reader :start_time, :end_time, :duration, :exclusive_duration, :guid, :starting_thread_id
         attr_accessor :name, :parent, :children_time, :transaction, :transaction_name
         attr_writer :record_metrics, :record_scoped_metric, :record_on_finish
         attr_reader :noticed_error
 
         def initialize name = nil, start_time = nil
           @name = name
+          @starting_thread_id = ::Thread.current.object_id
           @transaction_name = nil
           @transaction = nil
           @guid = NewRelic::Agent::GuidGenerator.generate_guid

data/lib/new_relic/agent/transaction/tracing.rb

@@ -6,7 +6,7 @@ module NewRelic
   module Agent
     class Transaction
       module Tracing
-        attr_reader :current_segment
+        attr_reader :current_segment_by_thread
 
         def async?
           @async ||= false
@@ -23,7 +23,7 @@ module NewRelic
         def add_segment segment, parent = nil
           segment.transaction = self
           segment.parent = parent || current_segment
-          @current_segment = segment
+          set_current_segment segment
           if @segments.length < segment_limit
             @segments << segment
           else
@@ -34,7 +34,12 @@ module NewRelic
         end
 
         def segment_complete segment
-          @current_segment = segment.parent
+          # if parent was in another thread, remove the current_segment entry for this thread
+          if segment.parent && segment.parent.starting_thread_id != ::Thread.current.object_id
+            remove_current_segment_by_thread_id(::Thread.current.object_id)
+          else
+            set_current_segment segment.parent
+          end
         end
 
         def segment_limit

data/lib/new_relic/agent/transaction.rb

@@ -217,7 +217,8 @@ module NewRelic
 
       def initialize(category, options)
         @nesting_max_depth = 0
-        @current_segment = nil
+        @current_segment_by_thread = {}
+        @current_segment_lock = Mutex.new
         @segments = []
 
         self.default_name = options[:transaction_name]
@@ -261,6 +262,25 @@ module NewRelic
         end
       end
 
+      def parent_thread_id
+        ::Thread.current.nr_parent_thread_id if ::Thread.current.respond_to?(:nr_parent_thread_id)
+      end
+
+      def current_segment
+        current_thread_id = ::Thread.current.object_id
+        return current_segment_by_thread[current_thread_id] if current_segment_by_thread[current_thread_id]
+        return current_segment_by_thread[parent_thread_id] if current_segment_by_thread[parent_thread_id]
+        current_segment_by_thread[@starting_thread_id]
+      end
+
+      def set_current_segment(new_segment)
+        @current_segment_lock.synchronize { current_segment_by_thread[::Thread.current.object_id] = new_segment }
+      end
+
+      def remove_current_segment_by_thread_id(id)
+        @current_segment_lock.synchronize { current_segment_by_thread.delete(id) }
+      end
+
       def distributed_tracer
         @distributed_tracer ||= DistributedTracer.new(self)
       end
@@ -719,9 +739,9 @@ module NewRelic
       # Do not call this.  Invoke the class method instead.
       def notice_error(error, options = {}) # :nodoc:
         # Only the last error is kept
-        if @current_segment
-          @current_segment.notice_error error, expected: options[:expected]
-          options[:span_id] = @current_segment.guid
+        if current_segment
+          current_segment.notice_error(error, expected: options[:expected])
+          options[:span_id] = current_segment.guid
         end
 
         if @exceptions[error]

data/lib/new_relic/agent/transaction_error_primitive.rb

@@ -63,6 +63,8 @@ module NewRelic
           append_cat payload, attrs
           DistributedTraceAttributes.copy_to_hash payload, attrs
           PayloadMetricMapping.append_mapped_metrics payload[:metrics], attrs
+        else
+          attrs[PRIORITY_KEY] = rand.round(NewRelic::PRIORITY_PRECISION)
         end
 
         attrs

data/lib/new_relic/agent/transaction_metrics.rb

@@ -13,6 +13,7 @@ module NewRelic
       DEFAULT_PROC = Proc.new { |hash, name| hash[name] = NewRelic::Agent::Stats.new }
 
       def initialize
+        @lock = Mutex.new
         @unscoped = Hash.new(&DEFAULT_PROC)
         @scoped = Hash.new(&DEFAULT_PROC)
       end
@@ -42,11 +43,11 @@ module NewRelic
       end
 
       def each_unscoped
-        @unscoped.each { |name, stats| yield name, stats }
+        @lock.synchronize { @unscoped.each { |name, stats| yield name, stats } }
       end
 
       def each_scoped
-        @scoped.each { |name, stats| yield name, stats }
+        @lock.synchronize { @scoped.each { |name, stats| yield name, stats } }
       end
 
       def _record_metrics(names, value, aux, target, &blk)
@@ -54,10 +55,10 @@ module NewRelic
         case names
         when Array
           names.each do |name|
-            target[name].record(value, aux, &blk)
+            @lock.synchronize { target[name].record(value, aux, &blk) }
           end
         else
-          target[names].record(value, aux, &blk)
+          @lock.synchronize { target[names].record(value, aux, &blk) }
         end
       end
     end

data/lib/new_relic/agent/vm/mri_vm.rb

@@ -49,7 +49,19 @@ module NewRelic
           end
 
           if supports?(:constant_cache_invalidations)
-            snap.constant_cache_invalidations = RubyVM.stat[:global_constant_state]
+            snap.constant_cache_invalidations = gather_constant_cache_invalidations
+          end
+        end
+
+        def gather_constant_cache_invalidations
+          # Ruby >= 3.2 uses :constant_cache
+          # see: https://github.com/ruby/ruby/pull/5433 and https://bugs.ruby-lang.org/issues/18589
+          # TODO: now that 3.2+ provides more granual cache invalidation data, should we report it instead of summing?
+          if RUBY_VERSION >= '3.2.0'
+            RubyVM.stat[:constant_cache].values.sum
+          # Ruby < 3.2 uses :global_constant_state
+          else
+            RubyVM.stat[:global_constant_state]
           end
         end
 

data/lib/new_relic/control/instrumentation.rb

@@ -62,9 +62,40 @@ module NewRelic
           File.join(instrumentation_path, app.to_s, '*.rb')
         @instrumentation_files.each { |pattern| load_instrumentation_files pattern }
         DependencyDetection.detect!
+        ruby_22_deprecation
+        rails_32_deprecation
         ::NewRelic::Agent.logger.info "Finished instrumentation"
       end
     end
+
+    def rails_32_deprecation
+      return unless defined?(Rails::VERSION) && Gem::Version.new(Rails::VERSION::STRING) <= Gem::Version.new('3.2')
+      deprecation_msg = 'The Ruby Agent is dropping support for Rails 3.2 ' \
+        'in a future major release. Please upgrade your Rails version to continue receiving support. ' \
+
+      Agent.logger.log_once(
+        :warn,
+        :deprecated_rails_version,
+        deprecation_msg
+      )
+
+      ::NewRelic::Agent.record_metric("Supportability/Deprecated/Rails32", 1)
+    end
+
+    def ruby_22_deprecation
+      return unless RUBY_VERSION <= '2.2.0'
+      deprecation_msg = 'The Ruby Agent is dropping support for Ruby 2.2 ' \
+        'in version 9.0.0. Please upgrade your Ruby version to continue receiving support. ' \
+
+      ::NewRelic::Agent.logger.log_once(
+        :warn,
+        :deprecated_ruby_version,
+        deprecation_msg
+      )
+
+      ::NewRelic::Agent.record_metric("Supportability/Deprecated/Ruby22", 1)
+    end
+
     include Instrumentation
   end
 end

data/lib/new_relic/dependency_detection.rb

@@ -146,7 +146,7 @@ module DependencyDetection
       !(disabled_configured? || deprecated_disabled_configured?)
     end
 
-    # TODO: Remove in 8.0
+    # TODO: MAJOR VERSION
     # will only return true if a disabled key is found and is truthy
     def deprecated_disabled_configured?
       return false if self.name.nil?

data/lib/new_relic/language_support.rb

@@ -34,6 +34,23 @@ module NewRelic
       RUBY_ENGINE == 'jruby'
     end
 
+    # TODO: OLD RUBIES - RUBY_VERSION < 2.6
+    #
+    # Ruby 2.6 introduced an improved version of `Object.const_get` that
+    # respects the full namespace of the input and doesn't just grab the first
+    # constant matching the string to the right of the last '::'.
+    # Once we drop support for Ruby 2.5 and below, the only value this custom
+    # method will provide beyond `Object.const_get` itself is to automatically
+    # catch NameError.
+    #
+    # see: https://github.com/rails/rails/commit/7057ccf6565c1cb5354c1906880119276a9d15c0
+    #
+    # With Ruby 2.6+, this method can be defined like so:
+    # def constantize(constant_as_string_or_symbol)
+    #   Object.const_get(constant_as_string_or_symbol)
+    # rescue NameError
+    # end
+    #
     def constantize(const_name)
       const_name.to_s.sub(/\A::/, '').split('::').inject(Object) do |namespace, name|
         begin