appsignal 3.6.5 → 3.7.1

data/lib/appsignal/probes.rb

@@ -2,6 +2,274 @@
 
 module Appsignal
   module Probes
+    class ProbeCollection
+      def initialize
+        @probes = {}
+      end
+
+      # @return [Integer] Number of probes that are registered.
+      def count
+        probes.count
+      end
+
+      # Clears all probes from the list.
+      # @return [void]
+      def clear
+        probes.clear
+      end
+
+      # Fetch a probe using its name.
+      # @param key [Symbol/String] The name of the probe to fetch.
+      # @return [Object] Returns the registered probe.
+      def [](key)
+        probes[key]
+      end
+
+      # @deprecated Use {Appsignal::Probes.register} instead.
+      def register(name, probe)
+        Appsignal::Utils::StdoutAndLoggerMessage.warning(
+          "The method 'Appsignal::Probes.probes.register' is deprecated. " \
+            "Use 'Appsignal::Probes.register' instead."
+        )
+        Appsignal::Probes.register(name, probe)
+      end
+
+      # @api private
+      def internal_register(name, probe)
+        if probes.key?(name)
+          logger.debug "A probe with the name `#{name}` is already " \
+            "registered. Overwriting the entry with the new probe."
+        end
+        probes[name] = probe
+      end
+
+      # @api private
+      def unregister(name)
+        probes.delete(name)
+      end
+
+      # @api private
+      def each(&block)
+        probes.each(&block)
+      end
+
+      private
+
+      attr_reader :probes
+
+      def logger
+        Appsignal.internal_logger
+      end
+    end
+
+    class << self
+      # @api private
+      def mutex
+        @mutex ||= Thread::Mutex.new
+      end
+
+      # @see ProbeCollection
+      # @return [ProbeCollection] Returns list of probes.
+      def probes
+        @probes ||= ProbeCollection.new
+      end
+
+      # Register a new minutely probe.
+      #
+      # Supported probe types are:
+      #
+      # - Lambda - A lambda is an object that listens to a `call` method call.
+      #   This `call` method is called every minute.
+      # - Class - A class object is an object that listens to a `new` and
+      #   `call` method call. The `new` method is called when the minutely
+      #   probe thread is started to initialize all probes. This allows probes
+      #   to load dependencies once beforehand. Their `call` method is called
+      #   every minute.
+      # - Class instance - A class instance object is an object that listens to
+      #   a `call` method call. The `call` method is called every minute.
+      #
+      # @example Register a new probe
+      #   Appsignal::Probes.register :my_probe, lambda {}
+      #
+      # @example Overwrite an existing registered probe
+      #   Appsignal::Probes.register :my_probe, lambda {}
+      #   Appsignal::Probes.register :my_probe, lambda { puts "hello" }
+      #
+      # @example Add a lambda as a probe
+      #   Appsignal::Probes.register :my_probe, lambda { puts "hello" }
+      #   # "hello" # printed every minute
+      #
+      # @example Add a probe instance
+      #   class MyProbe
+      #     def initialize
+      #       puts "started"
+      #     end
+      #
+      #     def call
+      #       puts "called"
+      #     end
+      #   end
+      #
+      #   Appsignal::Probes.register :my_probe, MyProbe.new
+      #   # "started" # printed immediately
+      #   # "called" # printed every minute
+      #
+      # @example Add a probe class
+      #   class MyProbe
+      #     def initialize
+      #       # Add things that only need to be done on start up for this probe
+      #       require "some/library/dependency"
+      #       @cache = {} # initialize a local cache variable
+      #       puts "started"
+      #     end
+      #
+      #     def call
+      #       puts "called"
+      #     end
+      #   end
+      #
+      #   Appsignal::Probes.register :my_probe, MyProbe
+      #   Appsignal::Probes.start # This is called for you
+      #   # "started" # Printed on Appsignal::Probes.start
+      #   # "called" # Repeated every minute
+      #
+      # @param name [Symbol/String] Name of the probe. Can be used with
+      #   {ProbeCollection#[]}. This name will be used in errors in the log and
+      #   allows overwriting of probes by registering new ones with the same
+      #   name.
+      # @param probe [Object] Any object that listens to the `call` method will
+      #   be used as a probe.
+      # @return [void]
+      def register(name, probe)
+        probes.internal_register(name, probe)
+
+        initialize_probe(name, probe) if started?
+      end
+
+      # Unregister a probe that's registered with {register}.
+      # Can also be used to unregister automatically registered probes by the
+      # gem.
+      #
+      # @example Unregister probes
+      #   # First register a probe
+      #   Appsignal::Probes.register :my_probe, lambda {}
+      #
+      #   # Then unregister a probe if needed
+      #   Appsignal::Probes.unregister :my_probe
+      #
+      # @param name [Symbol/String] Name of the probe used to {register} the
+      #   probe.
+      # @return [void]
+      def unregister(name)
+        probes.unregister(name)
+
+        uninitialize_probe(name)
+      end
+
+      # @api private
+      def start
+        stop
+        @started = true
+        @thread = Thread.new do
+          # Advise multi-threaded app servers to ignore this thread
+          # for the purposes of fork safety warnings
+          if Thread.current.respond_to?(:thread_variable_set)
+            Thread.current.thread_variable_set(:fork_safe, true)
+          end
+
+          sleep initial_wait_time
+          initialize_probes
+          loop do
+            logger = Appsignal.internal_logger
+            mutex.synchronize do
+              logger.debug("Gathering minutely metrics with #{probe_instances.count} probes")
+              probe_instances.each do |name, probe|
+                logger.debug("Gathering minutely metrics with '#{name}' probe")
+                probe.call
+              rescue => ex
+                logger.error "Error in minutely probe '#{name}': #{ex}"
+                logger.debug ex.backtrace.join("\n")
+              end
+            end
+            sleep wait_time
+          end
+        end
+      end
+
+      # Returns if the probes thread has been started. If the value is false or
+      # nil, it has not been started yet.
+      #
+      # @return [Boolean, nil]
+      def started?
+        @started
+      end
+
+      # Stop the minutely probes mechanism. Stop the thread and clear all probe
+      # instances.
+      def stop
+        defined?(@thread) && @thread.kill
+        @started = false
+        probe_instances.clear
+      end
+
+      # @api private
+      def wait_time
+        60 - Time.now.sec
+      end
+
+      private
+
+      def initial_wait_time
+        remaining_seconds = 60 - Time.now.sec
+        return remaining_seconds if remaining_seconds > 30
+
+        remaining_seconds + 60
+      end
+
+      def initialize_probes
+        probes.each do |name, probe|
+          initialize_probe(name, probe)
+        end
+      end
+
+      def initialize_probe(name, probe)
+        if probe.respond_to? :new
+          instance = probe.new
+          klass = probe
+        else
+          instance = probe
+          klass = instance.class
+        end
+        unless dependencies_present?(klass)
+          Appsignal.internal_logger.debug "Skipping '#{name}' probe, " \
+            "#{klass}.dependency_present? returned falsy"
+          return
+        end
+        mutex.synchronize do
+          probe_instances[name] = instance
+        end
+      rescue => error
+        logger = Appsignal.internal_logger
+        logger.error "Error while initializing minutely probe '#{name}': #{error}"
+        logger.debug error.backtrace.join("\n")
+      end
+
+      def uninitialize_probe(name)
+        mutex.synchronize do
+          probe_instances.delete(name)
+        end
+      end
+
+      def dependencies_present?(probe)
+        return true unless probe.respond_to? :dependencies_present?
+
+        probe.dependencies_present?
+      end
+
+      def probe_instances
+        @probe_instances ||= {}
+      end
+    end
   end
 end
 

data/lib/appsignal/utils/stdout_and_logger_message.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Appsignal
+  module Utils
+    # @api private
+    module StdoutAndLoggerMessage
+      def self.warning(message, logger = Appsignal.internal_logger)
+        Kernel.warn "appsignal WARNING: #{message}"
+        logger.warn message
+      end
+
+      def stdout_and_logger_warning(message, logger = Appsignal.internal_logger)
+        Appsignal::Utils::StdoutAndLoggerMessage.warning(message, logger)
+      end
+    end
+  end
+end

data/lib/appsignal/utils.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "appsignal/utils/deprecation_message"
+require "appsignal/utils/stdout_and_logger_message"
 require "appsignal/utils/data"
 require "appsignal/utils/hash_sanitizer"
 require "appsignal/utils/integration_logger"

data/lib/appsignal/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Appsignal
-  VERSION = "3.6.5"
+  VERSION = "3.7.1"
 end

data/lib/appsignal.rb

@@ -5,7 +5,7 @@ require "securerandom"
 require "stringio"
 
 require "appsignal/logger"
-require "appsignal/utils/deprecation_message"
+require "appsignal/utils/stdout_and_logger_message"
 require "appsignal/helpers/instrumentation"
 require "appsignal/helpers/metrics"
 
@@ -120,7 +120,7 @@ module Appsignal
             Appsignal::Environment.report_enabled("allocation_tracking")
           end
 
-          Appsignal::Minutely.start if config[:enable_minutely_probes]
+          Appsignal::Probes.start if config[:enable_minutely_probes]
 
           collect_environment_metadata
         else
@@ -152,6 +152,7 @@ module Appsignal
         internal_logger.debug("Stopping appsignal")
       end
       Appsignal::Extension.stop
+      Appsignal::Probes.stop
     end
 
     def forked
@@ -218,7 +219,10 @@ module Appsignal
         else
           Appsignal::Config::DEFAULT_LOG_LEVEL
         end
-      internal_logger << @in_memory_log.string if @in_memory_log
+      return unless @in_memory_log
+
+      internal_logger << @in_memory_log.string
+      @in_memory_log = nil
     end
 
     # Returns if the C-extension was loaded properly.
@@ -287,6 +291,22 @@ module Appsignal
       end
       Appsignal::Environment.report_supported_gems
     end
+
+    # Alias constants that have moved with a warning message that points to the
+    # place to update the reference.
+    def const_missing(name)
+      case name
+      when :Minutely
+        callers = caller
+        Appsignal::Utils::StdoutAndLoggerMessage.warning \
+          "The constant Appsignal::Minutely has been deprecated. " \
+            "Please update the constant name to Appsignal::Probes " \
+            "in the following file to remove this message.\n#{callers.first}"
+        Appsignal::Probes
+      else
+        super
+      end
+    end
   end
 end
 
@@ -300,10 +320,10 @@ require "appsignal/event_formatter"
 require "appsignal/hooks"
 require "appsignal/probes"
 require "appsignal/marker"
-require "appsignal/minutely"
 require "appsignal/garbage_collection"
 require "appsignal/integrations/railtie" if defined?(::Rails)
 require "appsignal/transaction"
 require "appsignal/version"
 require "appsignal/rack/generic_instrumentation"
 require "appsignal/transmitter"
+require "appsignal/heartbeat"

data/spec/lib/appsignal/config_spec.rb

@@ -172,6 +172,7 @@ describe Appsignal::Config do
         :filter_session_data            => [],
         :ignore_actions                 => [],
         :ignore_errors                  => [],
+        :ignore_logs                    => [],
         :ignore_namespaces              => [],
         :instrument_http_rb             => true,
         :instrument_net_http            => true,
@@ -421,6 +422,7 @@ describe Appsignal::Config do
         :dns_servers => ["8.8.8.8", "8.8.4.4"],
         :ignore_actions => %w[action1 action2],
         :ignore_errors => %w[ExampleStandardError AnotherError],
+        :ignore_logs => ["^start$", "^Completed 2.* in .*ms (.*)"],
         :ignore_namespaces => %w[admin private_namespace],
         :instrument_net_http => false,
         :instrument_redis => false,
@@ -443,6 +445,7 @@ describe Appsignal::Config do
       ENV["APPSIGNAL_DNS_SERVERS"]             = "8.8.8.8,8.8.4.4"
       ENV["APPSIGNAL_IGNORE_ACTIONS"]          = "action1,action2"
       ENV["APPSIGNAL_IGNORE_ERRORS"]           = "ExampleStandardError,AnotherError"
+      ENV["APPSIGNAL_IGNORE_LOGS"]             = "^start$,^Completed 2.* in .*ms (.*)"
       ENV["APPSIGNAL_IGNORE_NAMESPACES"]       = "admin,private_namespace"
       ENV["APPSIGNAL_INSTRUMENT_NET_HTTP"]     = "false"
       ENV["APPSIGNAL_INSTRUMENT_REDIS"]        = "false"
@@ -639,6 +642,7 @@ describe Appsignal::Config do
       config[:http_proxy] = "http://localhost"
       config[:ignore_actions] = %w[action1 action2]
       config[:ignore_errors] = %w[ExampleStandardError AnotherError]
+      config[:ignore_logs] = ["^start$", "^Completed 2.* in .*ms (.*)"]
       config[:ignore_namespaces] = %w[admin private_namespace]
       config[:log] = "stdout"
       config[:log_path] = "/tmp"
@@ -672,6 +676,7 @@ describe Appsignal::Config do
       expect(ENV.fetch("_APPSIGNAL_HTTP_PROXY", nil)).to eq "http://localhost"
       expect(ENV.fetch("_APPSIGNAL_IGNORE_ACTIONS", nil)).to eq "action1,action2"
       expect(ENV.fetch("_APPSIGNAL_IGNORE_ERRORS", nil)).to eq "ExampleStandardError,AnotherError"
+      expect(ENV.fetch("_APPSIGNAL_IGNORE_LOGS", nil)).to eq "^start$,^Completed 2.* in .*ms (.*)"
       expect(ENV.fetch("_APPSIGNAL_IGNORE_NAMESPACES", nil)).to eq "admin,private_namespace"
       expect(ENV.fetch("_APPSIGNAL_RUNNING_IN_CONTAINER", nil)).to eq "false"
       expect(ENV.fetch("_APPSIGNAL_ENABLE_HOST_METRICS", nil)).to eq "true"
@@ -752,7 +757,10 @@ describe Appsignal::Config do
     let(:out_stream) { std_stream }
     let(:output) { out_stream.read }
     let(:config) { project_fixture_config("production", :log_path => log_path) }
-    subject { capture_stdout(out_stream) { config.log_file_path } }
+
+    def log_file_path
+      capture_stdout(out_stream) { config.log_file_path }
+    end
 
     context "when path is writable" do
       let(:log_path) { File.join(tmp_dir, "writable-path") }
@@ -760,11 +768,11 @@ describe Appsignal::Config do
       after { FileUtils.rm_rf(log_path) }
 
       it "returns log file path" do
-        expect(subject).to eq File.join(log_path, "appsignal.log")
+        expect(log_file_path).to eq File.join(log_path, "appsignal.log")
       end
 
       it "prints no warning" do
-        subject
+        log_file_path
         expect(output).to be_empty
       end
     end
@@ -778,28 +786,47 @@ describe Appsignal::Config do
         before { FileUtils.chmod(0o777, system_tmp_dir) }
 
         it "returns returns the tmp location" do
-          expect(subject).to eq(File.join(system_tmp_dir, "appsignal.log"))
+          expect(log_file_path).to eq(File.join(system_tmp_dir, "appsignal.log"))
         end
 
         it "prints a warning" do
-          subject
+          log_file_path
           expect(output).to include "appsignal: Unable to log to '#{log_path}'. " \
             "Logging to '#{system_tmp_dir}' instead."
         end
+
+        it "prints a warning once" do
+          capture_stdout(out_stream) do
+            log_file_path
+            log_file_path
+          end
+          message = "appsignal: Unable to log to '#{log_path}'. " \
+            "Logging to '#{system_tmp_dir}' instead."
+          expect(output.scan(message).count).to eq(1)
+        end
       end
 
       context "when the /tmp fallback path is not writable" do
         before { FileUtils.chmod(0o555, system_tmp_dir) }
 
         it "returns nil" do
-          expect(subject).to be_nil
+          expect(log_file_path).to be_nil
         end
 
         it "prints a warning" do
-          subject
+          log_file_path
           expect(output).to include "appsignal: Unable to log to '#{log_path}' " \
             "or the '#{system_tmp_dir}' fallback."
         end
+
+        it "prints a warning once" do
+          capture_stdout(out_stream) do
+            log_file_path
+            log_file_path
+          end
+          message = "appsignal: Unable to log to '#{log_path}' or the '#{system_tmp_dir}' fallback."
+          expect(output.scan(message).count).to eq(1)
+        end
       end
     end
 
@@ -814,11 +841,11 @@ describe Appsignal::Config do
 
       context "when root_path is set" do
         it "returns returns the project log location" do
-          expect(subject).to eq File.join(config.root_path, "log/appsignal.log")
+          expect(log_file_path).to eq File.join(config.root_path, "log/appsignal.log")
         end
 
         it "prints no warning" do
-          subject
+          log_file_path
           expect(output).to be_empty
         end
       end
@@ -878,7 +905,7 @@ describe Appsignal::Config do
           end
 
           it "returns real path of log path" do
-            expect(subject).to eq(File.join(real_path, "appsignal.log"))
+            expect(log_file_path).to eq(File.join(real_path, "appsignal.log"))
           end
         end
       end

data/spec/lib/appsignal/heartbeat_spec.rb

@@ -0,0 +1,89 @@
+describe Appsignal::Heartbeat do
+  let(:config) { project_fixture_config }
+  let(:heartbeat) { described_class.new(:name => "heartbeat-name") }
+  let(:transmitter) { Appsignal::Transmitter.new("http://heartbeats/", config) }
+
+  before(:each) do
+    allow(Appsignal).to receive(:active?).and_return(true)
+    config.logger = Logger.new(StringIO.new)
+    allow(Appsignal::Heartbeat).to receive(:transmitter).and_return(transmitter)
+  end
+
+  describe "when Appsignal is not active" do
+    it "should not transmit any events" do
+      allow(Appsignal).to receive(:active?).and_return(false)
+      expect(transmitter).not_to receive(:transmit)
+
+      heartbeat.start
+      heartbeat.finish
+    end
+  end
+
+  describe "#start" do
+    it "should send a heartbeat start" do
+      expect(transmitter).to receive(:transmit).with(hash_including(
+        :name => "heartbeat-name",
+        :kind => "start"
+      )).and_return(nil)
+
+      heartbeat.start
+    end
+  end
+
+  describe "#finish" do
+    it "should send a heartbeat finish" do
+      expect(transmitter).to receive(:transmit).with(hash_including(
+        :name => "heartbeat-name",
+        :kind => "finish"
+      )).and_return(nil)
+
+      heartbeat.finish
+    end
+  end
+
+  describe ".heartbeat" do
+    describe "when a block is given" do
+      it "should send a heartbeat start and finish and return the block output" do
+        expect(transmitter).to receive(:transmit).with(hash_including(
+          :kind => "start",
+          :name => "heartbeat-with-block"
+        )).and_return(nil)
+
+        expect(transmitter).to receive(:transmit).with(hash_including(
+          :kind => "finish",
+          :name => "heartbeat-with-block"
+        )).and_return(nil)
+
+        output = Appsignal.heartbeat("heartbeat-with-block") { "output" }
+        expect(output).to eq("output")
+      end
+
+      it "should not send a heartbeat finish event when an error is raised" do
+        expect(transmitter).to receive(:transmit).with(hash_including(
+          :kind => "start",
+          :name => "heartbeat-with-block"
+        )).and_return(nil)
+
+        expect(transmitter).not_to receive(:transmit).with(hash_including(
+          :kind => "finish",
+          :name => "heartbeat-with-block"
+        ))
+
+        expect do
+          Appsignal.heartbeat("heartbeat-with-block") { raise "error" }
+        end.to raise_error(RuntimeError, "error")
+      end
+    end
+
+    describe "when no block is given" do
+      it "should only send a heartbeat finish event" do
+        expect(transmitter).to receive(:transmit).with(hash_including(
+          :kind => "finish",
+          :name => "heartbeat-without-block"
+        )).and_return(nil)
+
+        Appsignal.heartbeat("heartbeat-without-block")
+      end
+    end
+  end
+end

data/spec/lib/appsignal/hooks/gvl_spec.rb

@@ -93,7 +93,7 @@ describe Appsignal::Hooks::GvlHook do
           it "is added to minutely probes" do
             Appsignal::Hooks.load_hooks
 
-            expect(Appsignal::Minutely.probes[:gvl]).to be Appsignal::Probes::GvlProbe
+            expect(Appsignal::Probes.probes[:gvl]).to be Appsignal::Probes::GvlProbe
           end
         end
       end

data/spec/lib/appsignal/hooks/mri_spec.rb

@@ -16,7 +16,7 @@ describe Appsignal::Hooks::MriHook do
       end
 
       it "should be added to minutely probes" do
-        expect(Appsignal::Minutely.probes[:mri]).to be Appsignal::Probes::MriProbe
+        expect(Appsignal::Probes.probes[:mri]).to be Appsignal::Probes::MriProbe
       end
     end
   end

data/spec/lib/appsignal/hooks/puma_spec.rb

@@ -27,7 +27,7 @@ describe Appsignal::Hooks::PumaHook do
     end
 
     describe "installation" do
-      before { Appsignal::Minutely.probes.clear }
+      before { Appsignal::Probes.probes.clear }
 
       context "when not clustered mode" do
         it "does not add AppSignal stop behavior Puma::Cluster" do