appsignal 4.2.0 → 4.5.17

data/lib/appsignal/integrations/sidekiq.rb

@@ -58,6 +58,12 @@ module Appsignal
         error_message failed_at jid retried_at retry wrapped
       ].freeze
 
+      def self.sidekiq8?
+        return false unless ::Sidekiq.respond_to?(:gem_version)
+
+        @sidekiq8 ||= ::Sidekiq.gem_version >= Gem::Version.new("8.0.0")
+      end
+
       def call(_worker, item, _queue, &block)
         job_status = nil
         transaction = Appsignal::Transaction.create(Appsignal::Transaction::BACKGROUND_JOB)
@@ -74,7 +80,14 @@ module Appsignal
       ensure
         if transaction
           transaction.add_params_if_nil { parse_arguments(item) }
-          queue_start = (item["enqueued_at"].to_f * 1000.0).to_i # Convert seconds to milliseconds
+          enqueued_at = item["enqueued_at"]
+          queue_start =
+            if self.class.sidekiq8?
+              enqueued_at.to_i # Sidekiq 8 stores it as epoc milliseconds
+            else
+              # Convert seconds to milliseconds for Sidekiq 7 and older
+              (enqueued_at.to_f * 1000.0).to_i
+            end
           transaction.set_queue_start(queue_start)
           transaction.add_tags(:request_id => item["jid"])
           Appsignal::Transaction.complete_current! unless exception
@@ -143,8 +156,6 @@ module Appsignal
           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

data/lib/appsignal/internal_errors.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Appsignal
+  # @api private
+  class InternalError < StandardError; end
+
+  # @api private
+  class NotStartedError < InternalError
+    MESSAGE = <<~MESSAGE
+      The AppSignal Ruby gem was not started!
+
+      This error was raised by calling `Appsignal.check_if_started!`
+    MESSAGE
+
+    def message
+      MESSAGE
+    end
+  end
+end

data/lib/appsignal/logger.rb

@@ -9,6 +9,41 @@ module Appsignal
   # @see https://docs.appsignal.com/logging/platforms/integrations/ruby.html
   #   AppSignal Ruby logging documentation.
   class Logger < ::Logger
+    # A wrapper for a block that ensures it is only called once.
+    # If called again, it will return the result of the first call.
+    # This is useful for ensuring that a block is not executed multiple
+    # times when it is broadcasted to multiple loggers.
+    class BlockOnce
+      def initialize(&block)
+        @block = block
+        @called = false
+        @success = nil
+        @result = nil
+        @error = nil
+      end
+
+      def call(*args, **kwargs)
+        if @called
+          return @result if @success
+
+          raise @error
+        end
+
+        @called = true
+        @result = @block.call(*args, **kwargs)
+        @success = true
+        @result
+      rescue StandardError => e
+        @success = false
+        @error = e
+        raise @error
+      end
+
+      def to_proc
+        method(:call).to_proc
+      end
+    end
+
     PLAINTEXT = 0
     LOGFMT = 1
     JSON = 2
@@ -34,45 +69,75 @@ module Appsignal
 
       @group = group
       @level = level
+      @silenced = false
       @format = format
       @mutex = Mutex.new
       @default_attributes = attributes
+      @appsignal_attributes = attributes
+      @loggers = []
+    end
+
+    # When a formatter is set on the logger (e.g. when wrapping the logger in
+    # `ActiveSupport::TaggedLogging`) we want to set that formatter on all the
+    # loggers that are being broadcasted to.
+    def formatter=(formatter)
+      super
+      @loggers.each { |logger| logger.formatter = formatter }
     end
 
     # We support the various methods in the Ruby
     # logger class by supplying this method.
     # @api private
-    def add(severity, message = nil, group = nil)
+    def add(severity, message = nil, group = nil, &block) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+      # If we do not need to broadcast to any loggers and the severity is
+      # below the log level, we can return early.
       severity ||= UNKNOWN
-      return true if severity < level
+      return true if severity < level && @loggers.empty?
+
+      # If the logger is silenced, we do not log *or broadcast* messages
+      # below the log level.
+      return true if @silenced && severity < @level
 
+      # Ensure that the block is only run once, even if several loggers
+      # are being broadcasted to.
+      block = BlockOnce.new(&block) unless block.nil?
+
+      # If the group is not set, we use the default group.
       group = @group if group.nil?
-      if message.nil?
-        if block_given?
-          message = yield
-        else
-          message = group
-          group = @group
-        end
+
+      did_not_log = true
+
+      @loggers.each do |logger|
+        # Loggers should return true if they did *not* log the message.
+        # If any of the broadcasted loggers logs the message, that counts
+        # as having logged the message.
+        did_not_log &&= logger.add(severity, message, group, &block)
+      rescue
+        nil
       end
-      return if message.nil?
 
-      message = formatter.call(severity, Time.now, group, message) if formatter
+      # If the severity is below the log level, we do not log the message.
+      return did_not_log if severity < level
 
-      unless message.is_a?(String)
-        Appsignal.internal_logger.warn(
-          "Logger message was ignored, because it was not a String: #{message.inspect}"
-        )
-        return
+      message = block.call if block && message.nil?
+
+      return if message.nil?
+
+      if message.is_a?(Exception)
+        message = "#{message.class}: #{message.message} (#{message.backtrace[0]})"
       end
 
+      message = formatter.call(severity, Time.now, group, message) if formatter
+
       Appsignal::Extension.log(
         group,
         SEVERITY_MAP.fetch(severity, 0),
         @format,
-        message,
+        message.to_s,
         Appsignal::Utils::Data.generate(appsignal_attributes)
       )
+
+      false
     end
     alias log add
 
@@ -80,96 +145,83 @@ module Appsignal
     # @param message Message to log
     # @param attributes Attributes to tag the log with
     # @return [void]
-    def debug(message = nil, attributes = {})
-      return if level > DEBUG
-
-      message = yield if message.nil? && block_given?
-      return if message.nil?
-
-      add_with_attributes(DEBUG, message, @group, attributes)
+    def debug(message = nil, attributes = {}, &block)
+      add_with_attributes(DEBUG, message, @group, attributes, &block)
     end
 
     # Log an info level message
     # @param message Message to log
     # @param attributes Attributes to tag the log with
     # @return [void]
-    def info(message = nil, attributes = {})
-      return if level > INFO
-
-      message = yield if message.nil? && block_given?
-      return if message.nil?
-
-      add_with_attributes(INFO, message, @group, attributes)
+    def info(message = nil, attributes = {}, &block)
+      add_with_attributes(INFO, message, @group, attributes, &block)
     end
 
     # Log a warn level message
     # @param message Message to log
     # @param attributes Attributes to tag the log with
     # @return [void]
-    def warn(message = nil, attributes = {})
-      return if level > WARN
-
-      message = yield if message.nil? && block_given?
-      return if message.nil?
-
-      add_with_attributes(WARN, message, @group, attributes)
+    def warn(message = nil, attributes = {}, &block)
+      add_with_attributes(WARN, message, @group, attributes, &block)
     end
 
     # Log an error level message
     # @param message Message to log
     # @param attributes Attributes to tag the log with
     # @return [void]
-    def error(message = nil, attributes = {})
-      return if level > ERROR
-
-      message = yield if message.nil? && block_given?
-      return if message.nil?
-
-      message = "#{message.class}: #{message.message}" if message.is_a?(Exception)
-
-      add_with_attributes(ERROR, message, @group, attributes)
+    def error(message = nil, attributes = {}, &block)
+      add_with_attributes(ERROR, message, @group, attributes, &block)
     end
 
     # Log a fatal level message
     # @param message Message to log
     # @param attributes Attributes to tag the log with
     # @return [void]
-    def fatal(message = nil, attributes = {})
-      return if level > FATAL
-
-      message = yield if message.nil? && block_given?
-      return if message.nil?
+    def fatal(message = nil, attributes = {}, &block)
+      add_with_attributes(FATAL, message, @group, attributes, &block)
+    end
 
-      add_with_attributes(FATAL, message, @group, attributes)
+    # Log an info level message
+    #
+    # Returns the number of characters written.
+    #
+    # @param message Message to log
+    # @return [Integer]
+    def <<(message)
+      info(message)
+      message.length
     end
 
     # When using ActiveSupport::TaggedLogging without the broadcast feature,
     # the passed logger is required to respond to the `silence` method.
-    # In our case it behaves as the broadcast feature of the Rails logger, but
-    # we don't have to check if the parent logger has the `silence` method defined
-    # as our logger directly inherits from Ruby base logger.
     #
-    # Links:
+    # Reference links:
     #
     # - https://github.com/rails/rails/blob/e11ebc04cfbe41c06cdfb70ee5a9fdbbd98bb263/activesupport/lib/active_support/logger.rb#L60-L76
-    # - https://github.com/rails/rails/blob/main/activesupport/e11ebc04cfbe41c06cdfb70ee5a9fdbbd98bb263/active_support/logger_silence.rb
-    def silence(_severity = ERROR, &block)
-      block.call
+    # - https://github.com/rails/rails/blob/e11ebc04cfbe41c06cdfb70ee5a9fdbbd98bb263/activesupport/lib/active_support/logger_silence.rb
+    def silence(severity = ERROR, &block)
+      previous_level = @level
+      @level = severity
+      @silenced = true
+      block.call(self)
+    ensure
+      @level = previous_level
+      @silenced = false
+    end
+
+    def broadcast_to(logger)
+      @loggers << logger
     end
 
     private
 
-    attr_reader :default_attributes
+    attr_reader :default_attributes, :appsignal_attributes
 
-    def add_with_attributes(severity, message, group, attributes)
-      Thread.current[:appsignal_logger_attributes] = default_attributes.merge(attributes)
-      add(severity, message, group)
+    def add_with_attributes(severity, message, group, attributes, &block)
+      @appsignal_attributes = default_attributes.merge(attributes)
+      add(severity, message, group, &block)
     ensure
-      Thread.current[:appsignal_logger_attributes] = nil
-    end
-
-    def appsignal_attributes
-      Thread.current.fetch(:appsignal_logger_attributes, {})
+      @appsignal_attributes = default_attributes
     end
   end
 end

data/lib/appsignal/marker.rb

@@ -49,7 +49,7 @@ module Appsignal
     # @return [void]
     def transmit
       transmitter = Transmitter.new(ACTION, config)
-      puts "Notifying AppSignal of deploy with: " \
+      puts "Notifying AppSignal of '#{config.env}' deploy with " \
         "revision: #{marker_data[:revision]}, user: #{marker_data[:user]}"
 
       response = transmitter.transmit(marker_data)

data/lib/appsignal/probes/sidekiq.rb

@@ -59,7 +59,11 @@ module Appsignal
         is_sidekiq7 = self.class.sidekiq7_and_greater?
         @adapter = is_sidekiq7 ? Sidekiq7Adapter : Sidekiq6Adapter
 
-        config_string = " with config: #{config}" unless config.empty?
+        unless config.empty?
+          formatted_config =
+            config.map { |key, value| "#{key}: #{value.inspect}" }.join(", ")
+          config_string = " with config: #{formatted_config}"
+        end
         Appsignal.internal_logger.debug("Initializing Sidekiq probe#{config_string}")
         require "sidekiq/api"
       end

data/lib/appsignal/rack/body_wrapper.rb

@@ -4,7 +4,7 @@ module Appsignal
   module Rack
     # @api private
     class BodyWrapper
-      IGNORED_ERRORS = [Errno::EPIPE].freeze
+      IGNORED_ERRORS = [Errno::EPIPE, Errno::ECONNRESET].freeze
 
       def self.wrap(original_body, appsignal_transaction)
         # The logic of how Rack treats a response body differs based on which methods

data/lib/appsignal/rack/event_handler.rb

@@ -59,6 +59,7 @@ module Appsignal
           return unless request_handler?(request.env[APPSIGNAL_EVENT_HANDLER_ID])
 
           transaction = Appsignal::Transaction.create(Appsignal::Transaction::HTTP_REQUEST)
+          transaction.start_event
           request.env[APPSIGNAL_TRANSACTION] = transaction
 
           request.env[RACK_AFTER_REPLY] ||= []
@@ -67,7 +68,7 @@ module Appsignal
 
             Appsignal::Rack::EventHandler
               .safe_execution("Appsignal::Rack::EventHandler's after_reply") do
-              transaction.finish_event("process_request.rack", "", "")
+              transaction.finish_event("process_request.rack", "callback: after_reply", "")
               queue_start = Appsignal::Rack::Utils.queue_start_from(request.env)
               transaction.set_queue_start(queue_start) if queue_start
             end
@@ -81,9 +82,9 @@ module Appsignal
             # just a fallback if that doesn't get called.
             #
             # One such scenario is when a Puma "lowlevel_error" occurs.
-            Appsignal::Transaction.complete_current!
+            transaction.complete
+            Appsignal::Transaction.clear_current_transaction!
           end
-          transaction.start_event
         end
       end
 
@@ -111,7 +112,7 @@ module Appsignal
         return unless transaction
 
         self.class.safe_execution("Appsignal::Rack::EventHandler#on_finish") do
-          transaction.finish_event("process_request.rack", "", "")
+          transaction.finish_event("process_request.rack", "callback: on_finish", "")
           transaction.add_params_if_nil { request.params }
           transaction.add_headers_if_nil { request.env }
           transaction.add_session_data_if_nil do
@@ -138,7 +139,8 @@ module Appsignal
 
         # Make sure the current transaction is always closed when the request
         # is finished
-        Appsignal::Transaction.complete_current!
+        transaction.complete
+        Appsignal::Transaction.clear_current_transaction!
       end
 
       private

data/lib/appsignal/transaction.rb

@@ -27,23 +27,62 @@ module Appsignal
       # @param namespace [String] Namespace of the to be created transaction.
       # @return [Transaction]
       def create(namespace)
-        # Check if we already have a running transaction
+        # Reset the transaction if it was already completed but not cleared
+        if Thread.current[:appsignal_transaction]&.completed?
+          Thread.current[:appsignal_transaction] = nil
+        end
+
         if Thread.current[:appsignal_transaction].nil?
           # If not, start a new transaction
           set_current_transaction(Appsignal::Transaction.new(namespace))
         else
+          transaction = current
           # Otherwise, log the issue about trying to start another transaction
           Appsignal.internal_logger.warn(
             "Trying to start new transaction, but a transaction " \
-              "with id '#{current.transaction_id}' is already running. " \
-              "Using transaction '#{current.transaction_id}'."
+              "with id '#{transaction.transaction_id}' is already running. " \
+              "Using transaction '#{transaction.transaction_id}'."
           )
 
           # And return the current transaction instead
-          current
+          transaction
         end
       end
 
+      # @api private
+      # @return [Array<Proc>]
+      # Add a block, if given, to be executed after a transaction is created.
+      # The block will be called with the transaction as an argument.
+      # Returns the array of blocks that will be executed after a transaction
+      # is created.
+      def after_create(&block)
+        @after_create ||= Set.new
+
+        return @after_create if block.nil?
+
+        @after_create << block
+      end
+
+      # @api private
+      # @return [Array<Proc>]
+      # Add a block, if given, to be executed before a transaction is completed.
+      # This happens after duplicating the transaction for each error that was
+      # reported in the transaction -- that is, when a transaction with
+      # several errors is completed, the block will be called once for each
+      # error, with the transaction (either the original one or a duplicate of it)
+      # that has each of the errors set.
+      # The block will be called with the transaction as the first argument,
+      # and the error reported by the transaction, if any, as the second argument.
+      # Returns the array of blocks that will be executed before a transaction is
+      # completed.
+      def before_complete(&block)
+        @before_complete ||= Set.new
+
+        return @before_complete if block.nil?
+
+        @before_complete << block
+      end
+
       # @api private
       def set_current_transaction(transaction)
         Thread.current[:appsignal_transaction] = transaction
@@ -120,6 +159,7 @@ module Appsignal
       @namespace = namespace
       @paused = false
       @discarded = false
+      @completed = false
       @tags = {}
       @breadcrumbs = []
       @store = Hash.new { |hash, key| hash[key] = {} }
@@ -137,6 +177,8 @@ module Appsignal
         @namespace,
         0
       ) || Appsignal::Extension::MockTransaction.new
+
+      run_after_create_hooks
     end
 
     # @api private
@@ -149,6 +191,11 @@ module Appsignal
       false
     end
 
+    # @api private
+    def completed?
+      @completed
+    end
+
     # @api private
     def complete
       if discarded?
@@ -177,7 +224,7 @@ module Appsignal
           # In the duplicate transaction for each error, set an error
           # with a block that calls all the blocks set for that error
           # in the original transaction.
-          transaction.set_error(error) do
+          transaction.internal_set_error(error) do
             blocks.each { |block| block.call(transaction) }
           end
 
@@ -192,7 +239,12 @@ module Appsignal
           end
         end
       end
+
+      run_before_complete_hooks
+
       sample_data if should_sample
+
+      @completed = true
       @ext.complete
     end
 
@@ -520,17 +572,18 @@ module Appsignal
       return unless error
       return unless Appsignal.active?
 
-      _set_error(error) if @error_blocks.empty?
-
-      if !@error_blocks.include?(error) && @error_blocks.length >= ERRORS_LIMIT
-        Appsignal.internal_logger.warn "Appsignal::Transaction#add_error: Transaction has more " \
-          "than #{ERRORS_LIMIT} distinct errors. Only the first " \
-          "#{ERRORS_LIMIT} distinct errors will be reported."
+      if error.instance_variable_get(:@__appsignal_error_reported) && !@error_blocks.include?(error)
         return
       end
 
-      @error_blocks[error] << block
-      @error_blocks[error].compact!
+      internal_set_error(error, &block)
+
+      # Mark errors and their causes as tracked so we don't report duplicates,
+      # but also not error causes if the wrapper error is already reported.
+      while error
+        error.instance_variable_set(:@__appsignal_error_reported, true) unless error.frozen?
+        error = error.cause
+      end
     end
     alias :set_error :add_error
     alias_method :add_exception, :add_error
@@ -592,10 +645,35 @@ module Appsignal
     attr_writer :is_duplicate, :tags, :custom_data, :breadcrumbs, :params,
       :session_data, :headers
 
+    def internal_set_error(error, &block)
+      _set_error(error) if @error_blocks.empty?
+
+      if !@error_blocks.include?(error) && @error_blocks.length >= ERRORS_LIMIT
+        Appsignal.internal_logger.warn "Appsignal::Transaction#add_error: Transaction has more " \
+          "than #{ERRORS_LIMIT} distinct errors. Only the first " \
+          "#{ERRORS_LIMIT} distinct errors will be reported."
+        return
+      end
+      @error_blocks[error] << block
+      @error_blocks[error].compact!
+    end
+
     private
 
     attr_reader :breadcrumbs
 
+    def run_after_create_hooks
+      self.class.after_create.each do |block|
+        block.call(self)
+      end
+    end
+
+    def run_before_complete_hooks
+      self.class.before_complete.each do |block|
+        block.call(self, @error_set)
+      end
+    end
+
     def _set_error(error)
       backtrace = cleaned_backtrace(error.backtrace)
       @ext.set_error(

data/lib/appsignal/version.rb

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