appsignal 2.11.7 → 3.0.0

data/lib/appsignal/integrations/sidekiq.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module Appsignal
+  module Integrations
+    # Error handler for Sidekiq to report errors from jobs and internal Sidekiq
+    # errors.
+    #
+    # @api private
+    class SidekiqErrorHandler
+      def call(exception, sidekiq_context)
+        transaction = Appsignal::Transaction.current
+
+        if transaction.nil_transaction?
+          # Sidekiq error outside of the middleware scope.
+          # Can be a job JSON parse error or some other error happening in
+          # Sidekiq.
+          transaction = Appsignal::Transaction.create(
+            SecureRandom.uuid, # Newly generated job id
+            Appsignal::Transaction::BACKGROUND_JOB,
+            Appsignal::Transaction::GenericRequest.new({})
+          )
+          transaction.set_action_if_nil("SidekiqInternal")
+          transaction.set_metadata("sidekiq_error", sidekiq_context[:context])
+          transaction.params = { :jobstr => sidekiq_context[:jobstr] }
+        end
+
+        transaction.set_error(exception)
+        Appsignal::Transaction.complete_current!
+      end
+    end
+
+    # @api private
+    class SidekiqMiddleware # rubocop:disable Metrics/ClassLength
+      include Appsignal::Hooks::Helpers
+
+      EXCLUDED_JOB_KEYS = %w[
+        args backtrace class created_at enqueued_at error_backtrace error_class
+        error_message failed_at jid retried_at retry wrapped
+      ].freeze
+
+      def call(_worker, item, _queue)
+        job_status = nil
+        transaction = Appsignal::Transaction.create(
+          item["jid"],
+          Appsignal::Transaction::BACKGROUND_JOB,
+          Appsignal::Transaction::GenericRequest.new(
+            :queue_start => item["enqueued_at"]
+          )
+        )
+
+        Appsignal.instrument "perform_job.sidekiq" do
+          yield
+        end
+      rescue Exception => exception # rubocop:disable Lint/RescueException
+        job_status = :failed
+        raise exception
+      ensure
+        if transaction
+          transaction.set_action_if_nil(formatted_action_name(item))
+
+          params = filtered_arguments(item)
+          transaction.params = params if params
+
+          formatted_metadata(item).each do |key, value|
+            transaction.set_metadata key, value
+          end
+          transaction.set_http_or_background_queue_start
+          Appsignal::Transaction.complete_current! unless exception
+
+          queue = item["queue"] || "unknown"
+          if job_status
+            increment_counter "queue_job_count", 1,
+              :queue => queue,
+              :status => job_status
+          end
+          increment_counter "queue_job_count", 1,
+            :queue => queue,
+            :status => :processed
+        end
+      end
+
+      private
+
+      def increment_counter(key, value, tags = {})
+        Appsignal.increment_counter "sidekiq_#{key}", value, tags
+      end
+
+      def formatted_action_name(job)
+        sidekiq_action_name = parse_action_name(job)
+        return unless sidekiq_action_name
+
+        complete_action = sidekiq_action_name =~ /\.|#/
+        return sidekiq_action_name if complete_action
+
+        "#{sidekiq_action_name}#perform"
+      end
+
+      def filtered_arguments(job)
+        arguments = parse_arguments(job)
+        return unless arguments
+
+        Appsignal::Utils::HashSanitizer.sanitize(
+          arguments,
+          Appsignal.config[:filter_parameters]
+        )
+      end
+
+      def formatted_metadata(item)
+        {}.tap do |hash|
+          (item || {}).each do |key, value|
+            next if EXCLUDED_JOB_KEYS.include?(key)
+
+            hash[key] = truncate(string_or_inspect(value))
+          end
+        end
+      end
+
+      # Based on: https://github.com/mperham/sidekiq/blob/63ee43353bd3b753beb0233f64865e658abeb1c3/lib/sidekiq/api.rb#L316-L334
+      def parse_action_name(job)
+        args = job.fetch("args", [])
+        job_class = job["class"]
+        case job_class
+        when "Sidekiq::Extensions::DelayedModel"
+          safe_load(args[0], job_class) do |target, method, _|
+            "#{target.class}##{method}"
+          end
+        when /\ASidekiq::Extensions::Delayed/
+          safe_load(args[0], job_class) do |target, method, _|
+            "#{target}.#{method}"
+          end
+        else
+          job_class
+        end
+      end
+
+      # Based on: https://github.com/mperham/sidekiq/blob/63ee43353bd3b753beb0233f64865e658abeb1c3/lib/sidekiq/api.rb#L336-L358
+      def parse_arguments(job)
+        args = job.fetch("args", [])
+        case job["class"]
+        when /\ASidekiq::Extensions::Delayed/
+          safe_load(args[0], args) do |_, _, arg|
+            arg
+          end
+        when "ActiveJob::QueueAdapters::SidekiqAdapter::JobWrapper"
+          nil # Set in the ActiveJob integration
+        else
+          # Sidekiq Enterprise argument encryption.
+          # More information: https://github.com/mperham/sidekiq/wiki/Ent-Encryption
+          if job["encrypt".freeze]
+            # No point in showing 150+ bytes of random garbage
+            args[-1] = "[encrypted data]".freeze
+          end
+          args
+        end
+      end
+
+      # Based on: https://github.com/mperham/sidekiq/blob/63ee43353bd3b753beb0233f64865e658abeb1c3/lib/sidekiq/api.rb#L403-L412
+      def safe_load(content, default)
+        yield(*YAML.load(content))
+      rescue => error
+        # Sidekiq issue #1761: in dev mode, it's possible to have jobs enqueued
+        # which haven't been loaded into memory yet so the YAML can't be
+        # loaded.
+        Appsignal.logger.warn "Unable to load YAML: #{error.message}"
+        default
+      end
+    end
+  end
+end

data/lib/appsignal/integrations/unicorn.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Appsignal
+  module Integrations
+    module UnicornIntegration
+      # Make sure that appsignal is started and the last transaction
+      # in a worker gets flushed.
+      #
+      # We'd love to be able to hook this into Unicorn in a less
+      # intrusive way, but this is the best we can do given the
+      # options we have.
+
+      module Server
+        def worker_loop(worker)
+          Appsignal.forked
+          super
+        end
+      end
+
+      module Worker
+        def close
+          Appsignal.stop("unicorn")
+          super
+        end
+      end
+    end
+  end
+end

data/lib/appsignal/integrations/webmachine.rb

@@ -3,35 +3,33 @@
 module Appsignal
   module Integrations
     # @api private
-    module WebmachinePlugin
-      module FSM
-        def run_with_appsignal
-          transaction = Appsignal::Transaction.create(
-            SecureRandom.uuid,
-            Appsignal::Transaction::HTTP_REQUEST,
-            request,
-            :params_method => :query
-          )
+    module WebmachineIntegration
+      def run
+        transaction = Appsignal::Transaction.create(
+          SecureRandom.uuid,
+          Appsignal::Transaction::HTTP_REQUEST,
+          request,
+          :params_method => :query
+        )
 
-          transaction.set_action_if_nil("#{resource.class.name}##{request.method}")
+        transaction.set_action_if_nil("#{resource.class.name}##{request.method}")
 
-          Appsignal.instrument("process_action.webmachine") do
-            run_without_appsignal
-          end
-
-          Appsignal::Transaction.complete_current!
+        Appsignal.instrument("process_action.webmachine") do
+          super
         end
 
-        private
+        Appsignal::Transaction.complete_current!
+      end
+
+      private
 
-        def handle_exceptions_with_appsignal
-          handle_exceptions_without_appsignal do
-            begin
-              yield
-            rescue Exception => e # rubocop:disable Lint/RescueException
-              Appsignal.set_error(e)
-              raise e
-            end
+      def handle_exceptions
+        super do
+          begin
+            yield
+          rescue Exception => e # rubocop:disable Lint/RescueException
+            Appsignal.set_error(e)
+            raise e
           end
         end
       end

data/lib/appsignal/minutely.rb

@@ -3,8 +3,6 @@
 module Appsignal
   class Minutely
     class ProbeCollection
-      include Appsignal::Utils::DeprecationMessage
-
       def initialize
         @probes = {}
       end
@@ -27,16 +25,6 @@ module Appsignal
         probes[key]
       end
 
-      # @param probe [Object] Any object that listens to the `call` method will
-      #   be used as a probe.
-      # @deprecated Use {#register} instead.
-      # @return [void]
-      def <<(probe)
-        deprecation_message "Deprecated `Appsignal::Minute.probes <<` " \
-          "call. Please use `Appsignal::Minutely.probes.register` instead."
-        register probe.object_id, probe
-      end
-
       # Register a new minutely probe.
       #
       # Supported probe types are:
@@ -135,6 +123,12 @@ module Appsignal
       def start
         stop
         @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

data/lib/appsignal/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Appsignal
-  VERSION = "2.11.7".freeze
+  VERSION = "3.0.0".freeze
 end

data/spec/lib/appsignal/auth_check_spec.rb

@@ -28,29 +28,6 @@ describe Appsignal::AuthCheck do
     end.join("&")
   end
 
-  describe ".new" do
-    describe "with logger argument" do
-      let(:err_stream) { std_stream }
-      let(:stderr) { err_stream.read }
-      let(:log_stream) { std_stream }
-      let(:log) { log_contents(log_stream) }
-
-      it "logs and prints a deprecation message" do
-        Appsignal.logger = test_logger(log_stream)
-
-        capture_std_streams(std_stream, err_stream) do
-          Appsignal::AuthCheck.new(config, Appsignal.logger)
-        end
-
-        deprecation_message =
-          "`Appsignal::AuthCheck.new`'s `logger` argument " \
-          "will be removed in the next major version."
-        expect(stderr).to include "appsignal WARNING: #{deprecation_message}"
-        expect(log).to contains_log :warn, deprecation_message
-      end
-    end
-  end
-
   describe "#perform" do
     subject { auth_check.perform }
 
@@ -62,7 +39,7 @@ describe Appsignal::AuthCheck do
       end
     end
 
-    context "when encountering an exception", :not_ruby19 do
+    context "when encountering an exception" do
       before { stubbed_request.to_timeout }
 
       it "raises an error" do

data/spec/lib/appsignal/cli_spec.rb

@@ -16,7 +16,7 @@ describe Appsignal::CLI do
 
       expect(output).to include "appsignal <command> [options]"
       expect(output).to include \
-        "Available commands: demo, diagnose, install, notify_of_deploy"
+        "Available commands: demo, diagnose, install"
     end
   end
 

data/spec/lib/appsignal/config_spec.rb

@@ -168,8 +168,6 @@ describe Appsignal::Config do
         :push_api_key                   => "abc",
         :name                           => "TestApp",
         :active                         => true,
-        :enable_frontend_error_catching => false,
-        :frontend_error_catching_path   => "/appsignal_error_catcher",
         :enable_allocation_tracking     => true,
         :enable_gc_instrumentation      => false,
         :enable_host_metrics            => true,
@@ -357,70 +355,6 @@ describe Appsignal::Config do
         config
       end
     end
-
-    describe "support for old config keys" do
-      let(:err_stream) { std_stream }
-      let(:stderr) { err_stream.read }
-      let(:config) { project_fixture_config(env, {}, test_logger(log)) }
-      let(:log) { StringIO.new }
-      before { capture_std_streams(std_stream, err_stream) { config } }
-
-      describe ":api_key" do
-        context "without :push_api_key" do
-          let(:env) { "old_config" }
-
-          it "sets the :push_api_key with the old :api_key value" do
-            expect(config[:push_api_key]).to eq "def"
-            expect(config.config_hash).to_not have_key :api_key
-
-            message = "Old configuration key found. Please update the 'api_key' to 'push_api_key'"
-            expect(stderr).to include "appsignal WARNING: #{message}"
-            expect(log_contents(log)).to contains_log :warn, message
-          end
-        end
-
-        context "with :push_api_key" do
-          let(:env) { "old_config_mixed_with_new_config" }
-
-          it "ignores the :api_key config and deletes it" do
-            expect(config[:push_api_key]).to eq "ghi"
-            expect(config.config_hash).to_not have_key :api_key
-
-            message = "Old configuration key found. Please update the 'api_key' to 'push_api_key'"
-            expect(stderr).to include "appsignal WARNING: #{message}"
-            expect(log_contents(log)).to contains_log :warn, message
-          end
-        end
-      end
-
-      describe ":ignore_exceptions" do
-        context "without :ignore_errors" do
-          let(:env) { "old_config" }
-
-          it "sets :ignore_errors with the old :ignore_exceptions value" do
-            expect(config[:ignore_errors]).to eq ["StandardError"]
-            expect(config.config_hash).to_not have_key :ignore_exceptions
-
-            message = "Old configuration key found. Please update the 'ignore_exceptions' to 'ignore_errors'"
-            expect(stderr).to include "appsignal WARNING: #{message}"
-            expect(log_contents(log)).to contains_log :warn, message
-          end
-        end
-
-        context "with :ignore_errors" do
-          let(:env) { "old_config_mixed_with_new_config" }
-
-          it "ignores the :ignore_exceptions config" do
-            expect(config[:ignore_errors]).to eq ["NoMethodError"]
-            expect(config.config_hash).to_not have_key :ignore_exceptions
-
-            message = "Old configuration key found. Please update the 'ignore_exceptions' to 'ignore_errors'"
-            expect(stderr).to include "appsignal WARNING: #{message}"
-            expect(log_contents(log)).to contains_log :warn, message
-          end
-        end
-      end
-    end
   end
 
   context "with config in the environment" do

data/spec/lib/appsignal/event_formatter_spec.rb

@@ -114,43 +114,6 @@ describe Appsignal::EventFormatter do
         end
       end
     end
-
-    context "when registering deprecated formatters" do
-      let(:err_stream) { std_stream }
-      let(:stderr) { err_stream.read }
-      let(:deprecated_formatter) do
-        Class.new(Appsignal::EventFormatter) do
-          register "mock.deprecated"
-
-          def format(_payload)
-          end
-        end
-      end
-
-      it "registers deprecated formatters and logs & prints a warning" do
-        message = "Formatter for 'mock.deprecated' is using a deprecated registration method. " \
-          "This event formatter will not be loaded. " \
-          "Please update the formatter according to the documentation at: " \
-          "https://docs.appsignal.com/ruby/instrumentation/event-formatters.html"
-
-        logs = capture_logs do
-          capture_std_streams(std_stream, err_stream) { deprecated_formatter }
-        end
-        expect(logs).to contains_log :warn, message
-        expect(stderr).to include "appsignal WARNING: #{message}"
-
-        expect(klass.deprecated_formatter_classes.keys).to include("mock.deprecated")
-      end
-
-      it "initializes deprecated formatters" do
-        capture_std_streams(std_stream, err_stream) { deprecated_formatter }
-        klass.initialize_deprecated_formatters
-
-        expect(klass.registered?("mock.deprecated")).to be_truthy
-        expect(klass.formatters["mock.deprecated"]).to be_instance_of(deprecated_formatter)
-        expect(klass.deprecated_formatter_classes["mock.deprecated"]).to eq(deprecated_formatter)
-      end
-    end
   end
 
   describe ".registered?" do