newrelic_rpm 6.8.0.360 → 8.13.1

data/config.dot

@@ -90,7 +90,7 @@ digraph AgentEnabled {
   "Agent#log_seed_token"
   "Agent#log_error"
   "Agent#monitoring?"
-  "Agent#check_trasaction_sampler_status"
+  "Agent#check_transaction_sampler_status"
   "Agent#check_sql_sampler_status"
   "Agent#config_transaction_tracer"
   "Agent#set_sql_recording!"
@@ -134,8 +134,8 @@ digraph AgentEnabled {
 
   "MetricFrame.update_apdex"
 
-  "TranactionInfo#force_persist_sample?"
-  "TranactionInfo#include_guid?"
+  "TransactionInfo#force_persist_sample?"
+  "TransactionInfo#include_guid?"
 
   "TransactionSampleBuilder#initialize"
   "TransactionSampleBuilder#set_transaction_info"
@@ -257,8 +257,8 @@ digraph AgentEnabled {
 
   "MetricFrame.update_apdex" -> "[apdex_t]"
 
-  "TranactionInfo#force_persist_sample?" -> "[apdex_t]"
-  "TranactionInfo#include_guid?" -> "[apdex_t]"
+  "TransactionInfo#force_persist_sample?" -> "[apdex_t]"
+  "TransactionInfo#include_guid?" -> "[apdex_t]"
 
   "TransactionSampleBuilder#initialize" -> "[transaction_tracer.limit_segments]"
   "TransactionSampleBuilder#set_transaction_info" -> "[capture_params]"

data/docker-compose.yml

@@ -0,0 +1,107 @@
+version: "3.9"
+services:
+  elasticsearch7:
+    image: elasticsearch:7.16.2
+    ports:
+      - "9200:9200"
+    environment:
+      - discovery.type=single-node
+      - bootstrap.memory_lock=true
+      - "ES_JAVA_OPTS=-Xms512m -Xmx512m"
+    mem_limit: 1g
+  elasticsearch8:
+    image: elasticsearch:8.4.2
+    ports:
+      - "9250:9250"
+    environment:
+      - discovery.type=single-node
+      - xpack.security.enabled=false
+      - http.port=9250
+      - bootstrap.memory_lock=true
+      - "ES_JAVA_OPTS=-Xms512m -Xmx512m"
+    mem_limit: 1g
+  mysql:
+    image: mysql:5.7
+    restart: always
+    environment:
+      MYSQL_ROOT_PASSWORD: mysql_root_password
+      MYSQL_DATABASE: app
+    expose:
+      - "3306"
+    volumes:
+      - mysql:/var/lib/mysql
+  rabbitmq:
+    image: rabbitmq:3.9.12
+    restart: always
+    environment:
+      RABBITMQ_NODENAME: rabbit
+    expose:
+      - "5672"
+      - "15672"
+      - "25672"
+      - "4369"
+  memcached:
+    image: memcached:1.6.12
+    restart: always
+    expose:
+      - "11211"
+  mongodb:
+    image: mongo:5.0.4
+    restart: always
+    volumes:
+      - /data/db
+    expose:
+      - "27017"
+  postgres:
+    image: postgres:14.2
+    restart: always
+    environment:
+      POSTGRES_USER: admin
+      POSTGRES_PASSWORD: postgres_password
+    volumes:
+      - postgres:/var/lib/postgresql/data
+    expose:
+      - "5432"
+  redis:
+    image: redis:6.2.6
+    restart: always
+    volumes:
+      - /var/lib/redis
+    expose:
+      - "6379"
+  app:
+    build:
+      context: .
+      args:
+        - ruby_version=${RUBY_VERSION:-3.1}
+    image: newrelic_rpm
+    tty: true
+    stdin_open: true
+    environment:
+      MYSQL_USERNAME: root
+      MYSQL_PASSWORD: mysql_root_password
+      DATABASE_NAME: app
+      MYSQL_HOST: mysql
+      POSTGRES_USERNAME: admin
+      POSTGRES_PASSWORD: postgres_password
+    command: ["irb"]
+    volumes:
+      - ".:/usr/src/app"
+    depends_on:
+      - elasticsearch7
+      - elasticsearch8
+      - mysql
+      - memcached
+      - mongodb
+      - postgres
+      - rabbitmq
+      - redis
+    sysctls:
+      - "net.ipv6.conf.all.disable_ipv6=0"
+volumes:
+  mongodb:
+    driver: local
+  mysql:
+    driver: local
+  postgres:
+    driver: local

data/init.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
 
 # This is the initialization for the New Relic Ruby Agent when used as
 # a plugin
@@ -14,19 +14,17 @@ require 'new_relic/control'
 
 # Initializer for the NewRelic Ruby Agent
 
-# After verison 2.0 of Rails we can access the configuration directly.
+# After version 2.0 of Rails we can access the configuration directly.
 # We need it to add dev mode routes after initialization finished.
 
 begin
-
   current_config = if defined?(config)
     config
   elsif defined?(Rails.configuration)
     Rails.configuration
   end
 
-  NewRelic::Control.instance.init_plugin :config => current_config
-
+  NewRelic::Control.instance.init_plugin(:config => current_config)
 rescue => e
-  ::NewRelic::Agent.logger.error "Error initializing New Relic plugin. Agent is disabled.", e
+  ::NewRelic::Agent.logger.error("Error initializing New Relic plugin. Agent is disabled.", e)
 end

data/install.rb

@@ -1,8 +1,8 @@
-# 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
 
-if __FILE__ == $0 || $0 =~ /script\/plugin/ || File.basename($0) == 'rake'
+if __FILE__ == $0 || $0.include?('script/plugin') || File.basename($0) == 'rake'
   $LOAD_PATH << File.expand_path(File.join(File.dirname(__FILE__), 'lib'))
   require 'new_relic/cli/command'
   begin

data/lefthook.yml

@@ -0,0 +1,9 @@
+# Lefthook (https://github.com/evilmartians/lefthook) is a git hooks manager
+# Install it on your machine by running `gem install lefthook`
+pre-commit:
+  parallel: true
+  commands:
+    rubocop:
+      files: git diff --name-only --staged
+      glob: "*.rb"
+      run: rubocop --force-exclusion {files}

data/lib/new_relic/agent/adaptive_sampler.rb

@@ -1,19 +1,18 @@
-# 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 Agent
     class AdaptiveSampler
-
-      def initialize target_samples = 10, period_duration = 60
+      def initialize(target_samples = 10, period_duration = 60)
         @target = target_samples
         @seen = 0
         @seen_last = 0
         @sampled_count = 0
         @period_duration = period_duration
         @first_period = true
-        @period_start = Time.now.to_f
+        @period_start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
         @lock = Mutex.new
         register_config_callbacks
       end
@@ -29,7 +28,8 @@ module NewRelic
           elsif @sampled_count < @target
             rand(@seen_last) < @target
           else
-            rand(@seen) < (@target ** (@target / @sampled_count) - @target ** 0.5)
+            # you've met the target and need to exponentially back off
+            rand(@seen) < exponential_backoff
           end
 
           @sampled_count += 1 if sampled
@@ -39,6 +39,10 @@ module NewRelic
         end
       end
 
+      def exponential_backoff
+        @target**(@target.to_f / @sampled_count) - @target**0.5
+      end
+
       def stats
         @lock.synchronize do
           {
@@ -53,11 +57,11 @@ module NewRelic
       private
 
       def reset_if_period_expired!
-        now = Time.now.to_f
+        now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
         return unless @period_start + @period_duration <= now
 
         elapsed_periods = Integer((now - @period_start) / @period_duration)
-        @period_start = @period_start + elapsed_periods * @period_duration
+        @period_start += elapsed_periods * @period_duration
 
         @first_period = false
         @seen_last = elapsed_periods > 1 ? 0 : @seen
@@ -80,7 +84,7 @@ module NewRelic
             end
           end
           if target_changed
-            NewRelic::Agent.logger.debug "Sampling target set to: #{target}"
+            NewRelic::Agent.logger.debug("Sampling target set to: #{target}")
           end
         end
       end
@@ -95,7 +99,7 @@ module NewRelic
             end
           end
           if period_changed
-            NewRelic::Agent.logger.debug "Sampling period set to: #{period_duration}"
+            NewRelic::Agent.logger.debug("Sampling period set to: #{period_duration}")
           end
         end
       end

data/lib/new_relic/agent/agent/shutdown.rb

@@ -0,0 +1,35 @@
+# 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
+    module Shutdown
+      # Attempt a graceful shutdown of the agent, flushing any remaining
+      # data.
+      def shutdown
+        return unless started?
+
+        ::NewRelic::Agent.logger.info("Starting Agent shutdown")
+
+        stop_event_loop
+        trap_signals_for_litespeed
+        untraced_graceful_disconnect
+        revert_to_default_configuration
+
+        @started = nil
+        Control.reset
+      end
+
+      def untraced_graceful_disconnect
+        begin
+          NewRelic::Agent.disable_all_tracing do
+            graceful_disconnect
+          end
+        rescue => e
+          ::NewRelic::Agent.logger.error(e)
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/agent/special_startup.rb

@@ -0,0 +1,72 @@
+# 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
+    module SpecialStartup
+      # If we're using a dispatcher that forks before serving
+      # requests, we need to wait until the children are forked
+      # before connecting, otherwise the parent process sends useless data
+      def using_forking_dispatcher?
+        # TODO: MAJOR VERSION - remove :rainbows
+        if [:puma, :passenger, :rainbows, :unicorn].include?(Agent.config[:dispatcher])
+          ::NewRelic::Agent.logger.info("Deferring startup of agent reporting thread because #{Agent.config[:dispatcher]} may fork.")
+          true
+        else
+          false
+        end
+      end
+
+      # Return true if we're using resque and it hasn't had a chance to (potentially)
+      # daemonize itself. This avoids hanging when there's a Thread started
+      # before Resque calls Process.daemon (Jira RUBY-857)
+      def defer_for_resque?
+        NewRelic::Agent.config[:dispatcher] == :resque &&
+          NewRelic::Agent::Instrumentation::Resque::Helper.resque_fork_per_job? &&
+          !PipeChannelManager.listener.started?
+      end
+
+      def in_resque_child_process?
+        defined?(@service) && @service.is_a?(PipeService)
+      end
+
+      def defer_for_delayed_job?
+        NewRelic::Agent.config[:dispatcher] == :delayed_job &&
+          !NewRelic::DelayedJobInjection.worker_name
+      end
+
+      # This matters when the following three criteria are met:
+      #
+      # 1. A Sinatra 'classic' application is being run
+      # 2. The app is being run by executing the main file directly, rather
+      #    than via a config.ru file.
+      # 3. newrelic_rpm is required *after* sinatra
+      #
+      # In this case, the entire application runs from an at_exit handler in
+      # Sinatra, and if we were to install ours, it would be executed before
+      # the one in Sinatra, meaning that we'd shutdown the agent too early
+      # and never collect any data.
+      def sinatra_classic_app?
+        (
+          defined?(Sinatra::Application) &&
+          Sinatra::Application.respond_to?(:run) &&
+          Sinatra::Application.run?
+        )
+      end
+
+      def should_install_exit_handler?
+        return false unless Agent.config[:send_data_on_exit]
+
+        !sinatra_classic_app? || Agent.config[:force_install_exit_handler]
+      end
+
+      def install_exit_handler
+        return unless should_install_exit_handler?
+
+        NewRelic::Agent.logger.debug("Installing at_exit handler")
+        at_exit { shutdown }
+      end
+    end
+  end
+end

data/lib/new_relic/agent/agent/start_worker_thread.rb

@@ -0,0 +1,163 @@
+# 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
+    module StartWorkerThread
+      LOG_ONCE_KEYS_RESET_PERIOD = 60.0
+
+      TRANSACTION_EVENT_DATA = "transaction_event_data".freeze
+      CUSTOM_EVENT_DATA = "custom_event_data".freeze
+      ERROR_EVENT_DATA = "error_event_data".freeze
+      SPAN_EVENT_DATA = "span_event_data".freeze
+      LOG_EVENT_DATA = "log_event_data".freeze
+
+      # Try to launch the worker thread and connect to the server.
+      #
+      # See #connect for a description of connection_options.
+      def start_worker_thread(connection_options = {})
+        if disable = NewRelic::Agent.config[:disable_harvest_thread]
+          NewRelic::Agent.logger.info("Not starting Ruby Agent worker thread because :disable_harvest_thread is #{disable}")
+          return
+        end
+
+        ::NewRelic::Agent.logger.debug("Creating Ruby Agent worker thread.")
+        @worker_thread = Threading::AgentThread.create('Worker Loop') do
+          deferred_work!(connection_options)
+        end
+      end
+
+      def create_event_loop
+        EventLoop.new
+      end
+
+      # If the @worker_thread encounters an error during the attempt to connect to the collector
+      # then the connect attempts enter an exponential backoff retry loop.  To avoid potential
+      # race conditions with shutting down while also attempting to reconnect, we join the
+      # @worker_thread with a timeout threshold.  This allows potentially connecting and flushing
+      # pending data to the server, but without waiting indefinitely for a reconnect to succeed.
+      # The use-case where this typically arises is in cronjob scheduled rake tasks where there's
+      # also some network stability/latency issues happening.
+      def stop_event_loop
+        @event_loop.stop if @event_loop
+        # Wait the end of the event loop thread.
+        if @worker_thread
+          unless @worker_thread.join(3)
+            ::NewRelic::Agent.logger.debug("Event loop thread did not stop within 3 seconds")
+          end
+        end
+      end
+
+      # Certain event types may sometimes need to be on the same interval as metrics,
+      # so we will check config assigned in EventHarvestConfig to determine the interval
+      # on which to report them
+      def interval_for(event_type)
+        interval = Agent.config[:"event_report_period.#{event_type}"]
+        :"#{interval}_second_harvest"
+      end
+
+      def create_and_run_event_loop
+        data_harvest = :"#{Agent.config[:data_report_period]}_second_harvest"
+        event_harvest = :"#{Agent.config[:event_report_period]}_second_harvest"
+
+        @event_loop = create_event_loop
+        @event_loop.on(data_harvest) do
+          transmit_data
+        end
+
+        @event_loop.on(interval_for(TRANSACTION_EVENT_DATA)) do
+          transmit_analytic_event_data
+        end
+        @event_loop.on(interval_for(CUSTOM_EVENT_DATA)) do
+          transmit_custom_event_data
+        end
+        @event_loop.on(interval_for(ERROR_EVENT_DATA)) do
+          transmit_error_event_data
+        end
+        @event_loop.on(interval_for(SPAN_EVENT_DATA)) do
+          transmit_span_event_data
+        end
+        @event_loop.on(interval_for(LOG_EVENT_DATA)) do
+          transmit_log_event_data
+        end
+
+        @event_loop.on(:reset_log_once_keys) do
+          ::NewRelic::Agent.logger.clear_already_logged
+        end
+        @event_loop.fire_every(Agent.config[:data_report_period], data_harvest)
+        @event_loop.fire_every(Agent.config[:event_report_period], event_harvest)
+        @event_loop.fire_every(LOG_ONCE_KEYS_RESET_PERIOD, :reset_log_once_keys)
+
+        @event_loop.run
+      end
+
+      # Handles the case where the server tells us to restart -
+      # this clears the data, clears connection attempts, and
+      # waits a while to reconnect.
+      def handle_force_restart(error)
+        ::NewRelic::Agent.logger.debug(error.message)
+        drop_buffered_data
+        @service.force_restart if @service
+        @connect_state = :pending
+        sleep(30)
+      end
+
+      # when a disconnect is requested, stop the current thread, which
+      # is the worker thread that gathers data and talks to the
+      # server.
+      def handle_force_disconnect(error)
+        ::NewRelic::Agent.logger.warn("Agent received a ForceDisconnectException from the server, disconnecting. (#{error.message})")
+        disconnect
+      end
+
+      # Handles an unknown error in the worker thread by logging
+      # it and disconnecting the agent, since we are now in an
+      # unknown state.
+      def handle_other_error(error)
+        ::NewRelic::Agent.logger.error("Unhandled error in worker thread, disconnecting.")
+        # These errors are fatal (that is, they will prevent the agent from
+        # reporting entirely), so we really want backtraces when they happen
+        ::NewRelic::Agent.logger.log_exception(:error, error)
+        disconnect
+      end
+
+      # a wrapper method to handle all the errors that can happen
+      # in the connection and worker thread system. This
+      # guarantees a no-throw from the background thread.
+      def catch_errors
+        yield
+      rescue NewRelic::Agent::ForceRestartException => e
+        handle_force_restart(e)
+        retry
+      rescue NewRelic::Agent::ForceDisconnectException => e
+        handle_force_disconnect(e)
+      rescue => e
+        handle_other_error(e)
+      end
+
+      # This is the method that is run in a new thread in order to
+      # background the harvesting and sending of data during the
+      # normal operation of the agent.
+      #
+      # Takes connection options that determine how we should
+      # connect to the server, and loops endlessly - typically we
+      # never return from this method unless we're shutting down
+      # the agent
+      def deferred_work!(connection_options)
+        catch_errors do
+          NewRelic::Agent.disable_all_tracing do
+            connect(connection_options)
+            if connected?
+              create_and_run_event_loop
+              # never reaches here unless there is a problem or
+              # the agent is exiting
+            else
+              ::NewRelic::Agent.logger.debug("No connection.  Worker thread ending.")
+            end
+          end
+        end
+      end
+    end
+  end
+end