appsignal 2.4.0 → 2.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 73a704494489e09f2d92ffc41f9628aef70e9974
-  data.tar.gz: 267fe55728850ffe4802ea0761a748c809235de5
+  metadata.gz: 9969df5b54cc4d39fa5c1b3e5572715adbe9b912
+  data.tar.gz: a6ea0af4047d5cde79e766bdf34180b3600c2f97
 SHA512:
-  metadata.gz: cd3aa5683ed5c745a828caa4b4971cc1795056c91d990d114cd8e95737ce9bc02419b5255c91761cb3b5bec4aa1fdee9c59b47c6588f52a3f27679342ca2a14e
-  data.tar.gz: d2f42c59c32fc1dcfe7be0e64466d0afafc81e4d355b26c5b9618436ed9946b67e8988a960d689ada112798551833c4cc81fe6038a0de9c80487164f00ac3fc5
+  metadata.gz: 036c096b3039a580a5d75e472f0a0382e3e0b3f277b77ce8c5af16e4f0de539ee20a379c956c8715d7ee700b33392a3eca474d539b9a5697a24c6ff592a5cbd2
+  data.tar.gz: 574d5a9c4a20eb7dd8def062b90ec0978f5f0ff78e977a796e5a14043659405971d31ef4824df4c8be8554924f103f6c0699c5516f05f4bd5aa2ce552f6eb4df

data/.gitignore

@@ -25,6 +25,7 @@ bundle_and_spec_all_rvm
 ext/libappsignal.*
 ext/appsignal-agent
 ext/appsignal.h
+ext/appsignal.platform
 ext/appsignal.version
 ext/Makefile
 ext/*.bundle

data/.rubocop_todo.yml

@@ -13,7 +13,7 @@ Lint/HandleExceptions:
 
 # Offense count: 41
 Metrics/AbcSize:
-  Max: 59
+  Max: 59.92
 
 # Offense count: 5
 # Configuration parameters: CountComments.

data/.travis.yml

@@ -33,6 +33,7 @@ gemfile:
   - "gemfiles/sinatra.gemfile"
   - "gemfiles/grape.gemfile"
   - "gemfiles/webmachine.gemfile"
+  - "gemfiles/que.gemfile"
 
 matrix:
   fast_finish: true

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+# 2.4.1
+* Add Que integration. PR #361
+* Support Sidekiq delayed extension job action names better. Now action names
+  are reported as their class and class method name (`MyClass.method`), rather
+  than `Sidekiq::Extensions::DelayedClass#perform` for all jobs through that
+  extension. PR #362
+* Support Sidekiq Enterprise encrypted values. PR #365
+
 # 2.4.0
 - Add separate GNU linux build. PR #351 and
   Commit d1763f4dcb685608468a73f3192226f60f66b217

data/Rakefile

@@ -17,6 +17,7 @@ GEMFILES = %w(
   sinatra
   grape
   webmachine
+  que
 ).freeze
 
 RUBY_VERSIONS = %w(

data/ext/extconf.rb

@@ -6,19 +6,13 @@ require "zlib"
 require "rubygems/package"
 require "yaml"
 require File.expand_path("../../lib/appsignal/version.rb", __FILE__)
+require File.expand_path("../../lib/appsignal/system.rb", __FILE__)
 
 EXT_PATH     = File.expand_path("..", __FILE__).freeze
 AGENT_CONFIG = YAML.load(File.read(File.join(EXT_PATH, "agent.yml"))).freeze
 
-local_os = Gem::Platform.local.os
-chosen_os =
-  # Detect musl platforms
-  # Use `export APPSIGNAL_BUILD_FOR_MUSL=1` if the detection doesn't work.
-  if ENV["APPSIGNAL_BUILD_FOR_MUSL"] || (local_os =~ /linux/ && `ldd --version 2>&1` =~ /musl/)
-    "linux-musl"
-  end
-OS           = chosen_os || local_os
-ARCH         = "#{Gem::Platform.local.cpu}-#{OS}".freeze
+PLATFORM     = Appsignal::System.agent_platform
+ARCH         = "#{Gem::Platform.local.cpu}-#{PLATFORM}".freeze
 CA_CERT_PATH = File.join(EXT_PATH, "../resources/cacert.pem").freeze
 
 def ext_path(path)
@@ -36,8 +30,15 @@ def installation_failed(reason)
   end
 end
 
+def write_agent_platform
+  File.open(File.join(EXT_PATH, "appsignal.platform"), "w") do |file|
+    file.write PLATFORM
+  end
+end
+
 def install
   logger.info "Installing appsignal agent #{Appsignal::VERSION} for Ruby #{RUBY_VERSION} on #{RUBY_PLATFORM}"
+  write_agent_platform
 
   if RUBY_PLATFORM =~ /java/
     installation_failed(

data/gemfiles/que.gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+gem 'que'
+
+gemspec :path => '../'

data/lib/appsignal/cli/diagnose.rb

@@ -285,6 +285,8 @@ module Appsignal
             save :language, "ruby"
             puts_and_save :package_version, "Gem version", Appsignal::VERSION
             puts_and_save :agent_version, "Agent version", Appsignal::Extension.agent_version
+            puts_and_save :agent_platform, "Agent platform",
+              Appsignal::System.installed_agent_platform
             puts_and_save :package_install_path, "Gem install path", gem_path
             puts_and_save :extension_loaded, "Extension loaded", Appsignal.extension_loaded
           end
@@ -297,7 +299,7 @@ module Appsignal
             puts_and_save :architecture, "Architecture", rbconfig["host_cpu"]
 
             os_label = os = rbconfig["host_os"]
-            os_label = "#{os_label} (Microsoft Windows is not supported.)" if Gem.win_platform?
+            os_label = "#{os} (Microsoft Windows is not supported.)" if Gem.win_platform?
             save :os, os
             puts_value "Operating System", os_label
 

data/lib/appsignal/hooks.rb

@@ -102,3 +102,4 @@ require "appsignal/hooks/unicorn"
 require "appsignal/hooks/mongo_ruby_driver"
 require "appsignal/hooks/webmachine"
 require "appsignal/hooks/data_mapper"
+require "appsignal/hooks/que"

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/sidekiq.rb

@@ -1,64 +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
 
-      def job_keys
-        @job_keys ||= Set.new(%w(
-          class args retried_at failed_at
-          error_message error_class backtrace
-          error_backtrace enqueued_at retry
-          jid retry created_at wrapped
-        ))
-      end
+      JOB_KEYS = Set.new(%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)
-        args =
-          if item["class"] == "ActiveJob::QueueAdapters::SidekiqAdapter::JobWrapper"
-            item["args"].first["arguments"]
-          else
-            item["args"]
-          end
-        params = Appsignal::Utils::ParamsSanitizer.sanitize args,
-          :filter_parameters => Appsignal.config[:filter_parameters]
+        transaction = Appsignal::Transaction.create(
+          SecureRandom.uuid,
+          Appsignal::Transaction::BACKGROUND_JOB,
+          Appsignal::Transaction::GenericRequest.new(
+            :queue_start => item["enqueued_at"]
+          )
+        )
 
-        Appsignal.monitor_transaction(
-          "perform_job.sidekiq",
-          :class       => item["wrapped"] || item["class"],
-          :method      => "perform",
-          :metadata    => formatted_metadata(item),
-          :params      => params,
-          :queue_start => item["enqueued_at"],
-          :queue_time  => (Time.now.to_f - item["enqueued_at"].to_f) * 1000
-        ) do
-          yield
+        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 |hsh|
-          item.each do |key, val|
-            hsh[key] = truncate(string_or_inspect(val)) unless job_keys.include?(key)
+        {}.tap do |hash|
+          (item || {}).each do |key, value|
+            next if JOB_KEYS.include?(key)
+            hash[key] = truncate(string_or_inspect(value))
           end
         end
       end
-    end
 
-    class SidekiqHook < Appsignal::Hooks::Hook
-      register :sidekiq
-
-      def dependencies_present?
-        defined?(::Sidekiq)
+      # 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 "ActionMailer::DeliveryJob" == job_class
+            # MailerClass#mailer_method
+            args[0]["arguments"][0..1].join("#")
+          else
+            job_class
+          end
+        else
+          job["class"]
+        end
       end
 
-      def install
-        ::Sidekiq.configure_server do |config|
-          config.server_middleware do |chain|
-            chain.add Appsignal::Hooks::SidekiqPlugin
+      # 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 "ActionMailer::DeliveryJob" == (is_wrapped || args[0])
+            # 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/integrations/que.rb

@@ -0,0 +1,43 @@
+module Appsignal
+  module Integrations
+    module QuePlugin
+      def self.included(base)
+        base.class_eval do
+          def _run_with_appsignal
+            env = {
+              :metadata    => {
+                :id        => attrs[:job_id],
+                :queue     => attrs[:queue],
+                :run_at    => attrs[:run_at].to_s,
+                :priority  => attrs[:priority],
+                :attempts  => attrs[:error_count].to_i
+              },
+              :params => attrs[:args]
+            }
+
+            request = Appsignal::Transaction::GenericRequest.new(env)
+
+            transaction = Appsignal::Transaction.create(
+              SecureRandom.uuid,
+              Appsignal::Transaction::BACKGROUND_JOB,
+              request
+            )
+
+            begin
+              Appsignal.instrument("perform_job.que") { _run_without_appsignal }
+            rescue Exception => error # rubocop:disable Lint/RescueException
+              transaction.set_error(error)
+              raise error
+            ensure
+              transaction.set_action "#{attrs[:job_class]}#run"
+              Appsignal::Transaction.complete_current!
+            end
+          end
+
+          alias_method :_run_without_appsignal, :_run
+          alias_method :_run, :_run_with_appsignal
+        end
+      end
+    end
+  end
+end

data/lib/appsignal/system.rb

@@ -5,8 +5,62 @@ module Appsignal
   #
   # @api private
   module System
+    MUSL_TARGET = "linux-musl".freeze
+    GEM_EXT_PATH = File.expand_path("../../../ext", __FILE__).freeze
+
     def self.heroku?
       ENV.key? "DYNO".freeze
     end
+
+    # Returns the platform for which the agent was installed.
+    #
+    # This value is saved when the gem is installed in `ext/extconf.rb`.
+    # We use this value to build the diagnose report with the installed
+    # platform, rather than the detected platform in {.agent_platform} during
+    # the diagnose run.
+    #
+    # @api private
+    # @return [String]
+    def self.installed_agent_platform
+      platform_file = File.join(GEM_EXT_PATH, "appsignal.platform")
+      return unless File.exist?(platform_file)
+      File.read(platform_file)
+    end
+
+    # Detect agent and extension platform build
+    #
+    # Used by `ext/extconf.rb` to select which build it should download and
+    # install.
+    #
+    # Use `export APPSIGNAL_BUILD_FOR_MUSL=1` if the detection doesn't work
+    # and to force selection of the musl build.
+    #
+    # @api private
+    # @return [String]
+    def self.agent_platform
+      return MUSL_TARGET if ENV["APPSIGNAL_BUILD_FOR_MUSL"]
+
+      local_os = Gem::Platform.local.os
+      if local_os =~ /linux/
+        ldd_output = ldd_version_output
+        return MUSL_TARGET if ldd_output.include? "musl"
+        ldd_version = ldd_output.match(/\d+\.\d+/)
+        if ldd_version && versionify(ldd_version[0]) < versionify("2.15")
+          return MUSL_TARGET
+        end
+      end
+
+      local_os
+    end
+
+    # @api private
+    def self.versionify(version)
+      Gem::Version.new(version)
+    end
+
+    # @api private
+    def self.ldd_version_output
+      `ldd --version 2>&1`
+    end
   end
 end

data/lib/appsignal/transaction.rb

@@ -54,6 +54,12 @@ module Appsignal
       rescue => e
         Appsignal.logger.error("Failed to complete transaction ##{current.transaction_id}. #{e.message}")
       ensure
+        clear_current_transaction!
+      end
+
+      # Remove current transaction from current Thread.
+      # @api private
+      def clear_current_transaction!
         Thread.current[:appsignal_transaction] = nil
       end
 
@@ -312,6 +318,7 @@ module Appsignal
       finish_event(name, title, body, body_format)
     end
 
+    # @api private
     def to_h
       JSON.parse(@ext.to_json)
     end