appsignal 2.5.0.alpha.1-java

data/lib/appsignal/hooks/puma.rb

@@ -0,0 +1,35 @@
+module Appsignal
+  class Hooks
+    # @api private
+    class PumaHook < Appsignal::Hooks::Hook
+      register :puma
+
+      def dependencies_present?
+        defined?(::Puma) &&
+          ::Puma.respond_to?(:cli_config) &&
+          ::Puma.cli_config
+      end
+
+      def install
+        ::Puma.cli_config.options[:before_worker_boot] ||= []
+        ::Puma.cli_config.options[:before_worker_boot] << proc do |_id|
+          Appsignal.forked
+        end
+
+        ::Puma.cli_config.options[:before_worker_shutdown] ||= []
+        ::Puma.cli_config.options[:before_worker_shutdown] << proc do |_id|
+          Appsignal.stop("puma before_worker_shutdown")
+        end
+
+        ::Puma::Cluster.class_eval do
+          alias stop_workers_without_appsignal stop_workers
+
+          def stop_workers
+            Appsignal.stop("puma cluster")
+            stop_workers_without_appsignal
+          end
+        end
+      end
+    end
+  end
+end

data/lib/appsignal/hooks/que.rb

@@ -0,0 +1,21 @@
+module Appsignal
+  class Hooks
+    # @api private
+    class QueHook < Appsignal::Hooks::Hook
+      register :que
+
+      def dependencies_present?
+        defined?(::Que::Job)
+      end
+
+      def install
+        require "appsignal/integrations/que"
+        ::Que::Job.send(:include, Appsignal::Integrations::QuePlugin)
+
+        ::Que.error_notifier = proc do |error, _job|
+          Appsignal::Transaction.current.set_error(error)
+        end
+      end
+    end
+  end
+end

data/lib/appsignal/hooks/rake.rb

@@ -0,0 +1,39 @@
+module Appsignal
+  class Hooks
+    # @api private
+    class RakeHook < Appsignal::Hooks::Hook
+      register :rake
+
+      def dependencies_present?
+        defined?(::Rake::Task)
+      end
+
+      def install
+        ::Rake::Task.class_eval do
+          alias :execute_without_appsignal :execute
+
+          def execute(*args)
+            execute_without_appsignal(*args)
+          rescue Exception => error # rubocop:disable Lint/RescueException
+            # Format given arguments and cast to hash if possible
+            params, _ = args
+            params = params.to_hash if params.respond_to?(:to_hash)
+
+            transaction = Appsignal::Transaction.create(
+              SecureRandom.uuid,
+              Appsignal::Transaction::BACKGROUND_JOB,
+              Appsignal::Transaction::GenericRequest.new(
+                :params => params
+              )
+            )
+            transaction.set_action(name)
+            transaction.set_error(error)
+            transaction.complete
+            Appsignal.stop("rake")
+            raise error
+          end
+        end
+      end
+    end
+  end
+end

data/lib/appsignal/hooks/redis.rb

@@ -0,0 +1,30 @@
+module Appsignal
+  class Hooks
+    # @api private
+    class RedisHook < Appsignal::Hooks::Hook
+      register :redis
+
+      def dependencies_present?
+        defined?(::Redis) &&
+          Appsignal.config &&
+          Appsignal.config[:instrument_redis]
+      end
+
+      def install
+        ::Redis::Client.class_eval do
+          alias process_without_appsignal process
+
+          def process(commands, &block)
+            sanitized_commands = commands.map do |command, *args|
+              "#{command}#{" ?" * args.size}"
+            end.join("\n")
+
+            Appsignal.instrument "query.redis", id, sanitized_commands do
+              process_without_appsignal(commands, &block)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/appsignal/hooks/sequel.rb

@@ -0,0 +1,60 @@
+module Appsignal
+  class Hooks
+    # @api private
+    module SequelLogExtension
+      # Add query instrumentation
+      def log_yield(sql, args = nil)
+        Appsignal.instrument(
+          "sql.sequel",
+          nil,
+          sql,
+          Appsignal::EventFormatter::SQL_BODY_FORMAT
+        ) do
+          super
+        end
+      end
+    end
+
+    module SequelLogConnectionExtension
+      # Add query instrumentation
+      def log_connection_yield(sql, conn, args = nil)
+        Appsignal.instrument(
+          "sql.sequel",
+          nil,
+          sql,
+          Appsignal::EventFormatter::SQL_BODY_FORMAT
+        ) do
+          super
+        end
+      end
+    end
+
+    class SequelHook < Appsignal::Hooks::Hook
+      register :sequel
+
+      def dependencies_present?
+        defined?(::Sequel::Database) &&
+          Appsignal.config &&
+          Appsignal.config[:instrument_sequel]
+      end
+
+      def install
+        # Register the extension...
+        if ::Sequel::MAJOR >= 4 && ::Sequel::MINOR >= 35
+          ::Sequel::Database.register_extension(
+            :appsignal_integration,
+            Appsignal::Hooks::SequelLogConnectionExtension
+          )
+        else
+          ::Sequel::Database.register_extension(
+            :appsignal_integration,
+            Appsignal::Hooks::SequelLogExtension
+          )
+        end
+
+        # ... and automatically add it to future instances.
+        ::Sequel::Database.extension(:appsignal_integration)
+      end
+    end
+  end
+end

data/lib/appsignal/hooks/shoryuken.rb

@@ -0,0 +1,43 @@
+module Appsignal
+  class Hooks
+    # @api private
+    class ShoryukenMiddleware
+      def call(worker_instance, queue, sqs_msg, body)
+        metadata = { :queue => queue }.merge(sqs_msg.attributes)
+        options = {
+          :class => worker_instance.class.name,
+          :method => "perform",
+          :metadata => metadata
+        }
+
+        args = body.is_a?(Hash) ? body : { :params => body }
+        options[:params] = Appsignal::Utils::ParamsSanitizer.sanitize args,
+          :filter_parameters => Appsignal.config[:filter_parameters]
+
+        if sqs_msg.attributes.key?("SentTimestamp")
+          options[:queue_start] = Time.at(sqs_msg.attributes["SentTimestamp"].to_i / 1000)
+        end
+
+        Appsignal.monitor_transaction("perform_job.shoryuken", options) do
+          yield
+        end
+      end
+    end
+
+    class ShoryukenHook < Appsignal::Hooks::Hook
+      register :shoryuken
+
+      def dependencies_present?
+        defined?(::Shoryuken)
+      end
+
+      def install
+        ::Shoryuken.configure_server do |config|
+          config.server_middleware do |chain|
+            chain.add Appsignal::Hooks::ShoryukenMiddleware
+          end
+        end
+      end
+    end
+  end
+end

data/lib/appsignal/hooks/sidekiq.rb

@@ -0,0 +1,144 @@
+require "yaml"
+
+module Appsignal
+  class Hooks
+    class SidekiqHook < Appsignal::Hooks::Hook
+      register :sidekiq
+
+      def dependencies_present?
+        defined?(::Sidekiq)
+      end
+
+      def install
+        ::Sidekiq.configure_server do |config|
+          config.server_middleware do |chain|
+            chain.add Appsignal::Hooks::SidekiqPlugin
+          end
+        end
+      end
+    end
+
+    # @api private
+    class SidekiqPlugin
+      include Appsignal::Hooks::Helpers
+
+      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)
+        transaction = Appsignal::Transaction.create(
+          SecureRandom.uuid,
+          Appsignal::Transaction::BACKGROUND_JOB,
+          Appsignal::Transaction::GenericRequest.new(
+            :queue_start => item["enqueued_at"]
+          )
+        )
+
+        Appsignal.instrument "perform_job.sidekiq" do
+          begin
+            yield
+          rescue Exception => exception # rubocop:disable Lint/RescueException
+            transaction.set_error(exception)
+            raise exception
+          end
+        end
+      ensure
+        if transaction
+          transaction.set_action_if_nil(formatted_action_name(item))
+          transaction.params = filtered_arguments(item)
+          formatted_metadata(item).each do |key, value|
+            transaction.set_metadata key, value
+          end
+          transaction.set_http_or_background_queue_start
+          Appsignal::Transaction.complete_current!
+        end
+      end
+
+      private
+
+      def formatted_action_name(job)
+        sidekiq_action_name = parse_action_name(job)
+        return sidekiq_action_name if sidekiq_action_name =~ /\.|#/
+        "#{sidekiq_action_name}#perform"
+      end
+
+      def filtered_arguments(job)
+        Appsignal::Utils::ParamsSanitizer.sanitize(
+          parse_arguments(job),
+          :filter_parameters => Appsignal.config[:filter_parameters]
+        )
+      end
+
+      def formatted_metadata(item)
+        {}.tap do |hash|
+          (item || {}).each do |key, value|
+            next if 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["args"]
+        case job["class"]
+        when /\ASidekiq::Extensions::Delayed/
+          safe_load(job["args"][0], job["class"]) do |target, method, _|
+            "#{target}.#{method}"
+          end
+        when "ActiveJob::QueueAdapters::SidekiqAdapter::JobWrapper"
+          job_class = job["wrapped"] || args[0]
+          if job_class == "ActionMailer::DeliveryJob"
+            # MailerClass#mailer_method
+            args[0]["arguments"][0..1].join("#")
+          else
+            job_class
+          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["args"]
+        case job["class"]
+        when /\ASidekiq::Extensions::Delayed/
+          safe_load(args[0], args) do |_, _, arg|
+            arg
+          end
+        when "ActiveJob::QueueAdapters::SidekiqAdapter::JobWrapper"
+          is_wrapped = job["wrapped"]
+          job_args = is_wrapped ? args[0]["arguments"] : []
+          if (is_wrapped || args[0]) == "ActionMailer::DeliveryJob"
+            # Remove MailerClass, mailer_method and "deliver_now"
+            job_args.drop(3)
+          else
+            job_args
+          end
+        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/hooks/unicorn.rb

@@ -0,0 +1,40 @@
+module Appsignal
+  class Hooks
+    # @api private
+    class UnicornHook < Appsignal::Hooks::Hook
+      register :unicorn
+
+      def dependencies_present?
+        defined?(::Unicorn::HttpServer) &&
+          defined?(::Unicorn::Worker)
+      end
+
+      def install
+        # 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.
+
+        ::Unicorn::HttpServer.class_eval do
+          alias worker_loop_without_appsignal worker_loop
+
+          def worker_loop(worker)
+            Appsignal.forked
+            worker_loop_without_appsignal(worker)
+          end
+        end
+
+        ::Unicorn::Worker.class_eval do
+          alias close_without_appsignal close
+
+          def close
+            Appsignal.stop("unicorn")
+            close_without_appsignal
+          end
+        end
+      end
+    end
+  end
+end

data/lib/appsignal/hooks/webmachine.rb

@@ -0,0 +1,23 @@
+module Appsignal
+  class Hooks
+    # @api private
+    class WebmachineHook < Appsignal::Hooks::Hook
+      register :webmachine
+
+      def dependencies_present?
+        defined?(::Webmachine)
+      end
+
+      def install
+        require "appsignal/integrations/webmachine"
+        ::Webmachine::Decision::FSM.class_eval do
+          include Appsignal::Integrations::WebmachinePlugin::FSM
+          alias run_without_appsignal run
+          alias run run_with_appsignal
+          alias handle_exceptions_without_appsignal handle_exceptions
+          alias handle_exceptions handle_exceptions_with_appsignal
+        end
+      end
+    end
+  end
+end

data/lib/appsignal/integrations/capistrano/appsignal.cap

@@ -0,0 +1,39 @@
+namespace :appsignal do
+  task :deploy do
+    appsignal_env = fetch(:appsignal_env, fetch(:stage, fetch(:rails_env, fetch(:rack_env, "production"))))
+    user = fetch(:appsignal_user, ENV["USER"] || ENV["USERNAME"])
+    revision = fetch(:appsignal_revision, fetch(:current_revision))
+
+    appsignal_config = Appsignal::Config.new(
+      ENV["PWD"],
+      appsignal_env,
+      {},
+      Logger.new(StringIO.new)
+    ).tap do |c|
+      fetch(:appsignal_config, {}).each do |key, value|
+        c[key] = value
+      end
+      c.validate
+    end
+
+    if appsignal_config && appsignal_config.active?
+      marker_data = {
+        :revision => revision,
+        :user => user
+      }
+
+      marker = Appsignal::Marker.new(marker_data, appsignal_config)
+      # {#dry_run?} helper was added in Capistrano 3.5.0
+      # https://github.com/capistrano/capistrano/commit/38d8d6d2c8485f1b5643857465b16ff01da57aff
+      if respond_to?(:dry_run?) && dry_run?
+        puts "Dry run: AppSignal deploy marker not actually sent."
+      else
+        marker.transmit
+      end
+    else
+      puts "Not notifying of deploy, config is not active for environment: #{appsignal_env}"
+    end
+  end
+end
+
+after "deploy:finished", "appsignal:deploy"