appsignal 4.5.16 → 4.6.0

data/lib/appsignal/logger.rb

@@ -9,9 +9,50 @@ 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.
+    #
+    # @!visibility private
+    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
+
+    # @!visibility private
     PLAINTEXT = 0
+    # @!visibility private
     LOGFMT = 1
+    # @!visibility private
     JSON = 2
+    # @!visibility private
     SEVERITY_MAP = {
       DEBUG => 2,
       INFO => 3,
@@ -20,30 +61,34 @@ module Appsignal
       FATAL => 7
     }.freeze
 
+    # Logging severity threshold
+    # @return [Integer]
     attr_reader :level
 
     # Create a new logger instance
     #
-    # @param group Name of the group for this logger.
-    # @param level Minimum log level to report. Log lines below this level will be ignored.
-    # @param format Format to use to parse log line attributes.
-    # @param attributes Default attributes for all log lines.
+    # @param group [String] Name of the group for this logger.
+    # @param level [Integer] Minimum log level to report. Log lines below this
+    #   level will be ignored.
+    # @param format [Integer] Format to use to parse log line attributes.
+    # @param attributes [Hash<String, String>] Default attributes for all log lines.
     # @return [void]
     def initialize(group, level: INFO, format: PLAINTEXT, attributes: {})
       raise TypeError, "group must be a string" unless group.is_a? String
 
       @group = group
       @level = level
+      @silenced = false
       @format = format
       @mutex = Mutex.new
       @default_attributes = attributes
-      @appsignal_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.
+    # Sets the formatter for this logger and all broadcasted loggers.
+    # @param formatter [Proc] The formatter to use for log messages.
+    # @return [Proc]
     def formatter=(formatter)
       super
       @loggers.each { |logger| logger.formatter = formatter }
@@ -51,33 +96,44 @@ module Appsignal
 
     # We support the various methods in the Ruby
     # logger class by supplying this method.
-    # @api private
-    def add(severity, message = nil, group = nil)
+    # @!visibility private
+    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
-      end
-      return if message.nil?
+
+      did_not_log = true
 
       @loggers.each do |logger|
-        logger.add(severity, message, group)
+        # 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
 
-      unless message.is_a?(String)
-        Appsignal.internal_logger.warn(
-          "Logger message was ignored, because it was not a String: #{message.inspect}"
-        )
-        return
+      # If the severity is below the log level, we do not log the message.
+      return did_not_log if severity < level
+
+      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
@@ -86,90 +142,67 @@ module Appsignal
         group,
         SEVERITY_MAP.fetch(severity, 0),
         @format,
-        message,
+        message.to_s,
         Appsignal::Utils::Data.generate(appsignal_attributes)
       )
+
+      false
     end
     alias log add
 
     # Log a debug level message
-    # @param message Message to log
-    # @param attributes Attributes to tag the log with
+    # @param message [String] Message to log
+    # @param attributes [Hash<String, Object>] 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
+    # @param message [String] Message to log
+    # @param attributes [Hash<String, Object>] 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
+    # @param message [String] Message to log
+    # @param attributes [Hash<String, Object>] 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
+    # @param message [String, Exception] Message to log
+    # @param attributes [Hash<String, Object>] 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
+    # @param message [String, Exception] Message to log
+    # @param attributes [Hash<String, Object>] 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?
-
-      add_with_attributes(FATAL, message, @group, attributes)
+    def fatal(message = nil, attributes = {}, &block)
+      add_with_attributes(FATAL, message, @group, attributes, &block)
     end
 
     # Log an info level message
     #
     # Returns the number of characters written.
     #
-    # @param message Message to log
+    # @param message [String] Message to log
     # @return [Integer]
     def <<(message)
-      add(Logger::INFO, message)
+      info(message)
       message.length
     end
 
+    # Temporarily silences the logger to a specified level while executing a block.
+    #
     # When using ActiveSupport::TaggedLogging without the broadcast feature,
     # the passed logger is required to respond to the `silence` method.
     #
@@ -177,14 +210,22 @@ module Appsignal
     #
     # - https://github.com/rails/rails/blob/e11ebc04cfbe41c06cdfb70ee5a9fdbbd98bb263/activesupport/lib/active_support/logger.rb#L60-L76
     # - https://github.com/rails/rails/blob/e11ebc04cfbe41c06cdfb70ee5a9fdbbd98bb263/activesupport/lib/active_support/logger_silence.rb
+    #
+    # @param severity [Integer] The minimum severity level to log during the block.
+    # @return [Object] The return value of the block.
     def silence(severity = ERROR, &block)
       previous_level = @level
       @level = severity
+      @silenced = true
       block.call(self)
     ensure
       @level = previous_level
+      @silenced = false
     end
 
+    # Adds a logger to broadcast log messages to.
+    # @param logger [Logger] The logger to add to the broadcast list.
+    # @return [Array<Logger>]
     def broadcast_to(logger)
       @loggers << logger
     end
@@ -193,11 +234,11 @@ module Appsignal
 
     attr_reader :default_attributes, :appsignal_attributes
 
-    def add_with_attributes(severity, message, group, attributes)
+    def add_with_attributes(severity, message, group, attributes, &block)
       @appsignal_attributes = default_attributes.merge(attributes)
-      add(severity, message, group)
+      add(severity, message, group, &block)
     ensure
-      @appsignal_attributes = {}
+      @appsignal_attributes = default_attributes
     end
   end
 end

data/lib/appsignal/marker.rb

@@ -20,7 +20,7 @@ module Appsignal
   # @see Appsignal::CLI::NotifyOfDeploy
   # @see https://docs.appsignal.com/appsignal/terminology.html#markers
   #   Terminology: Deploy marker
-  # @api private
+  # @!visibility private
   class Marker
     # Path used on the AppSignal Push API
     # https://push.appsignal.com/1/markers

data/lib/appsignal/probes/gvl.rb

@@ -2,21 +2,22 @@
 
 module Appsignal
   module Probes
+    # @!visibility private
     class GvlProbe
       include Helpers
 
-      # @api private
+      # @!visibility private
       def self.dependencies_present?
         defined?(::GVLTools) && gvltools_0_2_or_newer? && ruby_3_2_or_newer? &&
           !Appsignal::System.jruby?
       end
 
-      # @api private
+      # @!visibility private
       def self.gvltools_0_2_or_newer?
         Gem::Version.new(::GVLTools::VERSION) >= Gem::Version.new("0.2.0")
       end
 
-      # @api private
+      # @!visibility private
       def self.ruby_3_2_or_newer?
         Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("3.2.0")
       end

data/lib/appsignal/probes/helpers.rb

@@ -2,7 +2,7 @@
 
 module Appsignal
   module Probes
-    # @api private
+    # @!visibility private
     module Helpers
       private
 

data/lib/appsignal/probes/mri.rb

@@ -2,11 +2,11 @@
 
 module Appsignal
   module Probes
-    # @api private
+    # @!visibility private
     class MriProbe
       include Helpers
 
-      # @api private
+      # @!visibility private
       def self.dependencies_present?
         defined?(::RubyVM) && ::RubyVM.respond_to?(:stat)
       end
@@ -17,7 +17,7 @@ module Appsignal
         @gc_profiler = gc_profiler
       end
 
-      # @api private
+      # @!visibility private
       def call
         stat = RubyVM.stat
 

data/lib/appsignal/probes/sidekiq.rb

@@ -2,7 +2,7 @@
 
 module Appsignal
   module Probes
-    # @api private
+    # @!visibility private
     class SidekiqProbe
       include Helpers
 
@@ -38,14 +38,15 @@ module Appsignal
         end
       end
 
-      # @api private
+      # @!visibility private
       attr_reader :config
 
+      # @!visibility private
       def self.sidekiq7_and_greater?
         Gem::Version.new(::Sidekiq::VERSION) >= Gem::Version.new("7.0.0")
       end
 
-      # @api private
+      # @!visibility private
       def self.dependencies_present?
         return true if sidekiq7_and_greater?
         return false unless defined?(::Redis::VERSION) # Sidekiq <= 6

data/lib/appsignal/probes.rb

@@ -2,10 +2,11 @@
 
 module Appsignal
   module Probes
-    # @api private
+    # @return [Integer]
+    # @!visibility private
     ITERATION_IN_SECONDS = 60
 
-    # @api private
+    # @!visibility private
     class ProbeCollection
       def initialize
         @probes = {}
@@ -23,13 +24,12 @@ module Appsignal
       end
 
       # Fetch a probe using its name.
-      # @param key [Symbol/String] The name of the probe to fetch.
+      # @param key [Symbol, String] The name of the probe to fetch.
       # @return [Object] Returns the registered probe.
       def [](key)
         probes[key]
       end
 
-      # @api private
       def internal_register(name, probe)
         if probes.key?(name)
           logger.debug "A probe with the name `#{name}` is already " \
@@ -38,12 +38,10 @@ module Appsignal
         probes[name] = probe
       end
 
-      # @api private
       def unregister(name)
         probes.delete(name)
       end
 
-      # @api private
       def each(&block)
         probes.each(&block)
       end
@@ -58,14 +56,14 @@ module Appsignal
     end
 
     class << self
-      # @api private
+      # @!visibility private
       def mutex
         @mutex ||= Thread::Mutex.new
       end
 
       # @see ProbeCollection
       # @return [ProbeCollection] Returns list of probes.
-      # @api private
+      # @!visibility private
       def probes
         @probes ||= ProbeCollection.new
       end
@@ -129,7 +127,7 @@ module Appsignal
       #   # "started" # Printed on Appsignal::Probes.start
       #   # "called" # Repeated every minute
       #
-      # @param name [Symbol/String] Name of the probe. Can be used with
+      # @param name [Symbol, String] Name of the probe. Can be used with
       #   {ProbeCollection#[]}. This name will be used in errors in the log and
       #   allows overwriting of probes by registering new ones with the same
       #   name.
@@ -153,7 +151,7 @@ module Appsignal
       #   # Then unregister a probe if needed
       #   Appsignal::Probes.unregister :my_probe
       #
-      # @param name [Symbol/String] Name of the probe used to {register} the
+      # @param name [Symbol, String] Name of the probe used to {register} the
       #   probe.
       # @return [void]
       def unregister(name)
@@ -162,6 +160,7 @@ module Appsignal
         uninitialize_probe(name)
       end
 
+      # @return [void]
       # @api private
       def start
         stop
@@ -184,8 +183,10 @@ module Appsignal
                 logger.debug("Gathering minutely metrics with '#{name}' probe")
                 probe.call
               rescue => ex
-                logger.error "Error in minutely probe '#{name}': #{ex}"
-                logger.debug ex.backtrace.join("\n")
+                logger.error(
+                  "Error in minutely probe '#{name}': #{ex.class}: #{ex.message}\n" \
+                    "#{ex.backtrace.join("\n")}"
+                )
               end
             end
             end_time = Time.now
@@ -212,13 +213,15 @@ module Appsignal
 
       # Stop the minutely probes mechanism. Stop the thread and clear all probe
       # instances.
+      #
+      # @return [void]
       def stop
         defined?(@thread) && @thread.kill
         @started = false
         probe_instances.clear
       end
 
-      # @api private
+      # @!visibility private
       def wait_time
         ITERATION_IN_SECONDS - Time.now.sec
       end
@@ -256,8 +259,10 @@ module Appsignal
         end
       rescue => error
         logger = Appsignal.internal_logger
-        logger.error "Error while initializing minutely probe '#{name}': #{error}"
-        logger.debug error.backtrace.join("\n")
+        logger.error(
+          "Error while initializing minutely probe '#{name}': #{error.class}: #{error.message}\n" \
+            "#{error.backtrace.join("\n")}"
+        )
       end
 
       def uninitialize_probe(name)

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Appsignal
-  # @api private
+  # @!visibility private
   module Rack
     APPSIGNAL_TRANSACTION = "appsignal.transaction"
     APPSIGNAL_EVENT_HANDLER_ID = "appsignal.event_handler_id"

data/lib/appsignal/sample_data.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Appsignal
-  # @api private
+  # @!visibility private
   class SampleData
     def initialize(key, accepted_type = nil)
       @key = key
@@ -21,7 +21,6 @@ module Appsignal
       end
     end
 
-    # @api private
     def set_empty_value!
       @empty = true
       @blocks.clear
@@ -36,12 +35,18 @@ module Appsignal
           else
             block_or_value
           end
+
         unless accepted_type?(new_value)
           log_unsupported_data_type(new_value)
           next
         end
 
-        value = merge_values(value, new_value)
+        # Before trying to merge values, convert them to Ruby classes
+        # This way we don't need to check if something is of a type often
+        value_new = convert_to_ruby_class(new_value)
+        value_original = convert_to_ruby_class(value)
+
+        value = merge_values(value_original, value_new)
         new_value
       end
 
@@ -52,7 +57,6 @@ module Appsignal
       @blocks.any?
     end
 
-    # @api private
     def empty?
       @empty
     end
@@ -81,15 +85,19 @@ module Appsignal
       end
     end
 
+    def mergable?(value_original, value_new)
+      value_new.instance_of?(value_original.class)
+    end
+
     def merge_values(value_original, value_new)
-      unless value_new.instance_of?(value_original.class)
-        unless value_original == UNSET_VALUE
-          Appsignal.internal_logger.warn(
-            "The sample data '#{@key}' changed type from " \
-              "'#{value_original.class}' to '#{value_new.class}'. " \
-              "These types can not be merged. Using new '#{value_new.class}' type."
-          )
-        end
+      return value_new if value_original == UNSET_VALUE
+
+      unless mergable?(value_original, value_new)
+        Appsignal.internal_logger.warn(
+          "The sample data '#{@key}' changed type from " \
+            "'#{value_original.class}' to '#{value_new.class}'. " \
+            "These types can not be merged. Using new '#{value_new.class}' type."
+        )
         return value_new
       end
 
@@ -103,6 +111,17 @@ module Appsignal
       end
     end
 
+    # Convert any subclasses of Hash to a Ruby Hash class, so we don't have to
+    # account for the original value being a value that's not a pure Hash or
+    # Array object.
+    def convert_to_ruby_class(value)
+      if value.is_a? Hash
+        value.to_h
+      else
+        value
+      end
+    end
+
     def log_unsupported_data_type(value)
       Appsignal.internal_logger.error(
         "Sample data '#{@key}': Unsupported data type '#{value.class}' received: #{value.inspect}"

data/lib/appsignal/span.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Appsignal
-  # @api private
+  # @!visibility private
   class Span
     def initialize(namespace = nil, ext = nil)
       @ext = ext || Appsignal::Extension::Span.root(namespace || "")