appsignal 2.11.0-java → 2.11.4-java

data/ext/appsignal_extension.c

@@ -485,7 +485,7 @@ static VALUE data_append_boolean(VALUE self, VALUE value) {
   return Qnil;
 }
 
-static VALUE data_append_nil(VALUE self, VALUE value) {
+static VALUE data_append_nil(VALUE self) {
   appsignal_data_t* data;
 
   Data_Get_Struct(self, appsignal_data_t, data);

data/ext/base.rb

@@ -119,30 +119,33 @@ def download_archive(type)
 
   version = AGENT_CONFIG["version"]
   filename = ARCH_CONFIG[type]["filename"]
-  attempted_mirror_urls = []
+  download_errors = []
 
   AGENT_CONFIG["mirrors"].each do |mirror|
     download_url = [mirror, version, filename].join("/")
-    attempted_mirror_urls << download_url
     report["download"]["download_url"] = download_url
 
     begin
-      return open(
+      args = [
         download_url,
         :ssl_ca_cert => CA_CERT_PATH,
         :proxy => http_proxy
-      )
-    rescue
+      ]
+      if URI.respond_to?(:open) # rubocop:disable Style/GuardClause
+        return URI.open(*args)
+      else
+        return open(*args)
+      end
+    rescue => error
+      download_errors << "- URL: #{download_url}\n  Error: #{error.class}: #{error.message}"
       next
     end
   end
 
-  attempted_mirror_urls_mapped = attempted_mirror_urls.map { |mirror| "- #{mirror}" }
   abort_installation(
     "Could not download archive from any of our mirrors. " \
-      "Attempted to download the archive from the following urls:\n" \
-      "#{attempted_mirror_urls_mapped.join("\n")}\n" \
-      "Please make sure your network allows access to any of these mirrors."
+      "Please make sure your network allows access to any of these mirrors.\n" \
+      "Attempted to download the archive from the following urls:\n#{download_errors.join("\n")}"
   )
 end
 

data/gemfiles/no_dependencies.gemfile

@@ -2,4 +2,11 @@ source 'https://rubygems.org'
 
 gem 'rack', '~> 1.6'
 
+ruby_version = Gem::Version.new(RUBY_VERSION)
+if ruby_version < Gem::Version.new("2.0.0")
+  # Newer versions of this gem have rexml as a dependency which doesn't work on
+  # Ruby 1.9
+  gem "crack", "0.4.4"
+end
+
 gemspec :path => '../'

data/gemfiles/resque-2.gemfile

@@ -2,7 +2,6 @@ source 'https://rubygems.org'
 
 gem 'resque', "~> 2.0"
 gem 'sinatra'
-gem 'mime-types', '~> 2.6'
 
 gemspec :path => '../'
 

data/gemfiles/webmachine.gemfile

@@ -1,5 +1,6 @@
 source 'https://rubygems.org'
 
 gem 'webmachine'
+gem 'webrick'
 
 gemspec :path => '../'

data/lib/appsignal/cli/diagnose/utils.rb

@@ -34,20 +34,17 @@ module Appsignal
         end
 
         def self.parse_yaml(contents)
-          arguments = [contents]
           if YAML.respond_to? :safe_load
-            method = :safe_load
-            arguments << \
-              if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("2.6.0")
-                # Use keyword params for Ruby 2.6 and up
-                { :permitted_classes => [Time] }
-              else
-                [Time]
-              end
+            if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("2.6.0")
+              # Use keyword params for Ruby 2.6 and up
+              YAML.safe_load(contents, :permitted_classes => [Time])
+            else
+              YAML.safe_load(contents, [Time])
+            end
           else
-            method = :load
+            # Support for Ruby versions without YAML.safe_load
+            YAML.load(contents) # rubocop:disable Security/YAMLLoad
           end
-          YAML.send(method, *arguments)
         end
       end
     end

data/lib/appsignal/cli/install.rb

@@ -278,14 +278,11 @@ module Appsignal
             "../../../resources/appsignal.yml.erb"
           )
           file_contents = File.read(filename)
-          arguments = [file_contents]
-          if ruby_2_6_or_up?
-            arguments << { :trim_mode => "-" }
-          else
-            arguments << nil
-            arguments << "-"
-          end
-          template = ERB.new(*arguments)
+          template = if ruby_2_6_or_up?
+                       ERB.new(file_contents, :trim_mode => "-")
+                     else
+                       ERB.new(file_contents, nil, "-")
+                     end
           config = template.result(OpenStruct.new(data).instance_eval { binding })
 
           FileUtils.mkdir_p(File.join(Dir.pwd, "config"))

data/lib/appsignal/helpers/instrumentation.rb

@@ -380,6 +380,38 @@ module Appsignal
       end
       alias :tag_job :tag_request
 
+      # Add breadcrumbs to the transaction.
+      #
+      # Breadcrumbs can be used to trace what path a user has taken
+      # before encounterin an error.
+      #
+      # Only the last 20 added breadcrumbs will be saved.
+      #
+      # @example
+      #   Appsignal.add_breadcrumb("Navigation", "http://blablabla.com", "", { :response => 200 }, Time.now.utc)
+      #   Appsignal.add_breadcrumb("Network", "[GET] http://blablabla.com", "", { :response => 500 })
+      #   Appsignal.add_breadcrumb("UI", "closed modal(change_password)", "User closed modal without actions")
+      #
+      # @param category [String] category of breadcrumb
+      #   e.g. "UI", "Network", "Navigation", "Console".
+      # @param action [String] name of breadcrumb
+      #   e.g "The user clicked a button", "HTTP 500 from http://blablabla.com"
+      # @option message [String]  optional message in string format
+      # @option metadata [Hash<String,String>]  key/value metadata in <string, string> format
+      # @option time [Time] time of breadcrumb, should respond to `.to_i` defaults to `Time.now.utc`
+      # @return [void]
+      #
+      # @see Transaction#add_breadcrumb
+      # @see http://docs.appsignal.com/ruby/instrumentation/breadcrumbs.html
+      #   Breadcrumb reference
+      # @since 2.12.0
+      def add_breadcrumb(category, action, message = "", metadata = {}, time = Time.now.utc)
+        return unless active?
+        transaction = Appsignal::Transaction.current
+        return false unless transaction
+        transaction.add_breadcrumb(category, action, message, metadata, time)
+      end
+
       # Instrument helper for AppSignal.
       #
       # For more help, read our custom instrumentation guide, listed under "See

data/lib/appsignal/hooks.rb

@@ -96,6 +96,7 @@ module Appsignal
 end
 
 require "appsignal/hooks/action_cable"
+require "appsignal/hooks/action_mailer"
 require "appsignal/hooks/active_job"
 require "appsignal/hooks/active_support_notifications"
 require "appsignal/hooks/celluloid"

data/lib/appsignal/hooks/action_mailer.rb

@@ -0,0 +1,22 @@
+module Appsignal
+  class Hooks
+    class ActionMailerHook < Appsignal::Hooks::Hook
+      register :action_mailer
+
+      def dependencies_present?
+        defined?(::ActionMailer)
+      end
+
+      def install
+        ActiveSupport::Notifications
+          .subscribe("process.action_mailer") do |_, _, _, _, payload|
+          Appsignal.increment_counter(
+            :action_mailer_process,
+            1,
+            :mailer => payload[:mailer], :action => payload[:action]
+          )
+        end
+      end
+    end
+  end
+end

data/lib/appsignal/hooks/active_support_notifications.rb

@@ -23,6 +23,21 @@ module Appsignal
           end
         end
 
+        instrumenter = ::ActiveSupport::Notifications::Instrumenter
+
+        if instrumenter.method_defined?(:start) && instrumenter.method_defined?(:finish)
+          install_start_finish
+        else
+          install_instrument
+        end
+
+        # rubocop:disable Style/GuardClause
+        if instrumenter.method_defined?(:finish_with_state)
+          install_finish_with_state
+        end
+      end
+
+      def install_instrument
         ::ActiveSupport::Notifications::Instrumenter.class_eval do
           alias instrument_without_appsignal instrument
 
@@ -46,6 +61,63 @@ module Appsignal
           end
         end
       end
+
+      def install_start_finish
+        ::ActiveSupport::Notifications::Instrumenter.class_eval do
+          alias start_without_appsignal start
+
+          def start(name, payload = {})
+            # Events that start with a bang are internal to Rails
+            instrument_this = name[0] != BANG
+
+            Appsignal::Transaction.current.start_event if instrument_this
+
+            start_without_appsignal(name, payload)
+          end
+
+          alias finish_without_appsignal finish
+
+          def finish(name, payload = {})
+            # Events that start with a bang are internal to Rails
+            instrument_this = name[0] != BANG
+
+            if instrument_this
+              title, body, body_format = Appsignal::EventFormatter.format(name, payload)
+              Appsignal::Transaction.current.finish_event(
+                name.to_s,
+                title,
+                body,
+                body_format
+              )
+            end
+
+            finish_without_appsignal(name, payload)
+          end
+        end
+      end
+
+      def install_finish_with_state
+        ::ActiveSupport::Notifications::Instrumenter.class_eval do
+          alias finish_with_state_without_appsignal finish_with_state
+
+          def finish_with_state(listeners_state, name, payload = {})
+            # Events that start with a bang are internal to Rails
+            instrument_this = name[0] != BANG
+
+            if instrument_this
+              title, body, body_format = Appsignal::EventFormatter.format(name, payload)
+              Appsignal::Transaction.current.finish_event(
+                name.to_s,
+                title,
+                body,
+                body_format
+              )
+            end
+
+            finish_with_state_without_appsignal(listeners_state, name, payload)
+          end
+        end
+      end
     end
   end
 end

data/lib/appsignal/hooks/shoryuken.rb

@@ -5,21 +5,60 @@ module Appsignal
     # @api private
     class ShoryukenMiddleware
       def call(worker_instance, queue, sqs_msg, body)
-        metadata = { :queue => queue }.merge(sqs_msg.attributes)
+        batch = sqs_msg.is_a?(Array)
+        attributes =
+          if batch
+            # We can't instrument batched message separately, the `yield` will
+            # perform all the batched messages.
+            # To provide somewhat useful metadata, Get first message based on
+            # SentTimestamp, and use its attributes as metadata for the
+            # transaction. We can't combine them all because then they would
+            # overwrite each other and the last message (in an sorted order)
+            # would be used as the source of the metadata.  With the
+            # oldest/first message at least some useful information is stored
+            # such as the first received time and the number of retries for the
+            # first message. The newer message should have lower values and
+            # timestamps in their metadata.
+            first_msg = sqs_msg.min do |a, b|
+              a.attributes["SentTimestamp"].to_i <=> b.attributes["SentTimestamp"].to_i
+            end
+            # Add batch => true metadata so people can recognize when a
+            # transaction is about a batch of messages.
+            first_msg.attributes.merge(:batch => true)
+          else
+            sqs_msg.attributes.merge(:message_id => sqs_msg.message_id)
+          end
+        metadata = { :queue => queue }.merge(attributes)
         options = {
           :class => worker_instance.class.name,
           :method => "perform",
           :metadata => metadata
         }
 
-        args = body.is_a?(Hash) ? body : { :params => body }
+        args =
+          if batch
+            bodies = {}
+            sqs_msg.each_with_index do |msg, index|
+              # Store all separate bodies on a hash with the key being the
+              # message_id
+              bodies[msg.message_id] = body[index]
+            end
+            bodies
+          else
+            case body
+            when Hash
+              body
+            else
+              { :params => body }
+            end
+          end
         options[:params] = Appsignal::Utils::HashSanitizer.sanitize(
           args,
           Appsignal.config[:filter_parameters]
         )
 
-        if sqs_msg.attributes.key?("SentTimestamp")
-          options[:queue_start] = Time.at(sqs_msg.attributes["SentTimestamp"].to_i / 1000)
+        if attributes.key?("SentTimestamp")
+          options[:queue_start] = Time.at(attributes["SentTimestamp"].to_i / 1000)
         end
 
         Appsignal.monitor_transaction("perform_job.shoryuken", options) do

data/lib/appsignal/integrations/object.rb

@@ -4,38 +4,8 @@ if defined?(Appsignal)
   Appsignal::Environment.report_enabled("object_instrumentation")
 end
 
-class Object
-  def self.appsignal_instrument_class_method(method_name, options = {})
-    singleton_class.send \
-      :alias_method, "appsignal_uninstrumented_#{method_name}", method_name
-    singleton_class.send(:define_method, method_name) do |*args, &block|
-      name = options.fetch(:name) do
-        "#{method_name}.class_method.#{appsignal_reverse_class_name}.other"
-      end
-      Appsignal.instrument name do
-        send "appsignal_uninstrumented_#{method_name}", *args, &block
-      end
-    end
-  end
-
-  def self.appsignal_instrument_method(method_name, options = {})
-    alias_method "appsignal_uninstrumented_#{method_name}", method_name
-    define_method method_name do |*args, &block|
-      name = options.fetch(:name) do
-        "#{method_name}.#{appsignal_reverse_class_name}.other"
-      end
-      Appsignal.instrument name do
-        send "appsignal_uninstrumented_#{method_name}", *args, &block
-      end
-    end
-  end
-
-  def self.appsignal_reverse_class_name
-    return "AnonymousClass" unless name
-    name.split("::").reverse.join(".")
-  end
-
-  def appsignal_reverse_class_name
-    self.class.appsignal_reverse_class_name
-  end
+if RUBY_VERSION < "2.0"
+  require "appsignal/integrations/object_ruby_19"
+else
+  require "appsignal/integrations/object_ruby_modern"
 end

data/lib/appsignal/integrations/object_ruby_19.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+class Object
+  def self.appsignal_instrument_class_method(method_name, options = {})
+    singleton_class.send \
+      :alias_method, "appsignal_uninstrumented_#{method_name}", method_name
+    singleton_class.send(:define_method, method_name) do |*args, &block|
+      name = options.fetch(:name) do
+        "#{method_name}.class_method.#{appsignal_reverse_class_name}.other"
+      end
+      Appsignal.instrument name do
+        send "appsignal_uninstrumented_#{method_name}", *args, &block
+      end
+    end
+  end
+
+  def self.appsignal_instrument_method(method_name, options = {})
+    alias_method "appsignal_uninstrumented_#{method_name}", method_name
+    define_method method_name do |*args, &block|
+      name = options.fetch(:name) do
+        "#{method_name}.#{appsignal_reverse_class_name}.other"
+      end
+      Appsignal.instrument name do
+        send "appsignal_uninstrumented_#{method_name}", *args, &block
+      end
+    end
+  end
+
+  def self.appsignal_reverse_class_name
+    return "AnonymousClass" unless name
+    name.split("::").reverse.join(".")
+  end
+
+  def appsignal_reverse_class_name
+    self.class.appsignal_reverse_class_name
+  end
+end

data/lib/appsignal/integrations/object_ruby_modern.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+class Object
+  if Appsignal::System.ruby_2_7_or_newer?
+    def self.appsignal_instrument_class_method(method_name, options = {})
+      singleton_class.send \
+        :alias_method, "appsignal_uninstrumented_#{method_name}", method_name
+      singleton_class.send(:define_method, method_name) do |*args, **kwargs, &block|
+        name = options.fetch(:name) do
+          "#{method_name}.class_method.#{appsignal_reverse_class_name}.other"
+        end
+        Appsignal.instrument name do
+          send "appsignal_uninstrumented_#{method_name}", *args, **kwargs, &block
+        end
+      end
+    end
+
+    def self.appsignal_instrument_method(method_name, options = {})
+      alias_method "appsignal_uninstrumented_#{method_name}", method_name
+      define_method method_name do |*args, **kwargs, &block|
+        name = options.fetch(:name) do
+          "#{method_name}.#{appsignal_reverse_class_name}.other"
+        end
+        Appsignal.instrument name do
+          send "appsignal_uninstrumented_#{method_name}", *args, **kwargs, &block
+        end
+      end
+    end
+  else
+    def self.appsignal_instrument_class_method(method_name, options = {})
+      singleton_class.send \
+        :alias_method, "appsignal_uninstrumented_#{method_name}", method_name
+      singleton_class.send(:define_method, method_name) do |*args, &block|
+        name = options.fetch(:name) do
+          "#{method_name}.class_method.#{appsignal_reverse_class_name}.other"
+        end
+        Appsignal.instrument name do
+          send "appsignal_uninstrumented_#{method_name}", *args, &block
+        end
+      end
+    end
+
+    def self.appsignal_instrument_method(method_name, options = {})
+      alias_method "appsignal_uninstrumented_#{method_name}", method_name
+      define_method method_name do |*args, &block|
+        name = options.fetch(:name) do
+          "#{method_name}.#{appsignal_reverse_class_name}.other"
+        end
+        Appsignal.instrument name do
+          send "appsignal_uninstrumented_#{method_name}", *args, &block
+        end
+      end
+    end
+  end
+
+  def self.appsignal_reverse_class_name
+    return "AnonymousClass" unless name
+    name.split("::").reverse.join(".")
+  end
+
+  def appsignal_reverse_class_name
+    self.class.appsignal_reverse_class_name
+  end
+end