Improve formatter efficiency and MultiErrorReporter customization

Author: ndbroadbent

lib/log_struct/formatter.rb

@@ -73,13 +73,7 @@ def process_values(arg, recursion_depth: 0)
 
         result
       when Array
-        result = arg.map { |value| process_values(value, recursion_depth: recursion_depth + 1) }
-
-        # Filter large arrays, but don't truncate backtraces (arrays of strings that look like file:line)
-        if result.size > 10 && !looks_like_backtrace?(result)
-          result = result.take(10) + ["... and #{result.size - 10} more items"]
-        end
-        result
+        process_array(arg, recursion_depth: recursion_depth)
       when GlobalID::Identification
         begin
           arg.to_global_id
@@ -91,7 +85,7 @@ def process_values(arg, recursion_depth: 0)
             else
               # For non-ActiveRecord objects that failed to_global_id, try to get a string representation
               # If this also fails, we want to catch it and return the error placeholder
-              T.unsafe(arg).to_s
+              String(T.cast(arg, Object))
             end
           rescue => e
             LogStruct.handle_exception(e, source: Source::Internal)
@@ -207,17 +201,35 @@ def generate_json(data)
       "#{data.to_json}\n"
     end
 
+    sig { params(array: T::Array[T.untyped], recursion_depth: Integer).returns(T::Array[T.untyped]) }
+    def process_array(array, recursion_depth:)
+      return [] if array.empty?
+
+      if looks_like_backtrace_array?(array)
+        array.map { |value| process_values(value, recursion_depth: recursion_depth + 1) }
+      else
+        processed = []
+        array.each_with_index do |value, index|
+          break if index >= 10
+
+          processed << process_values(value, recursion_depth: recursion_depth + 1)
+        end
+
+        if array.size > 10
+          processed << "... and #{array.size - 10} more items"
+        end
+
+        processed
+      end
+    end
+
     # Check if an array looks like a backtrace (array of strings with file:line pattern)
     sig { params(array: T::Array[T.untyped]).returns(T::Boolean) }
-    def looks_like_backtrace?(array)
-      return false if array.empty?
-
-      # Check if most elements look like backtrace lines (file.rb:123 or similar patterns)
+    def looks_like_backtrace_array?(array)
       backtrace_like_count = array.first(5).count do |element|
         element.is_a?(String) && element.match?(/\A[^:\s]+:\d+/)
       end
 
-      # If at least 3 out of the first 5 elements look like backtrace lines, treat as backtrace
       backtrace_like_count >= 3
     end
   end

lib/log_struct/log/shared/serialize_common_public.rb

@@ -20,10 +20,10 @@ def serialize_common_public(strict = true)
           raise ArgumentError, "Public log struct must define #source and #event"
         end
 
-        src_val = T.unsafe(self).source
-        evt_val = T.unsafe(self).event
-        src = src_val.respond_to?(:serialize) ? T.unsafe(src_val).serialize.to_s : src_val.to_s
-        evt = evt_val.respond_to?(:serialize) ? T.unsafe(evt_val).serialize.to_s : evt_val.to_s
+        src_val = public_send(:source)
+        evt_val = public_send(:event)
+        src = src_val.respond_to?(:serialize) ? src_val.public_send(:serialize).to_s : src_val.to_s
+        evt = evt_val.respond_to?(:serialize) ? evt_val.public_send(:serialize).to_s : evt_val.to_s
         lvl = level.serialize.to_s
         ts = timestamp.iso8601(3)
 

lib/log_struct/multi_error_reporter.rb

@@ -2,6 +2,7 @@
 # frozen_string_literal: true
 
 require_relative "enums/error_reporter"
+require_relative "handlers"
 
 # Try to require all supported error reporting libraries
 # Users may have multiple installed, so we should load all of them
@@ -19,33 +20,62 @@ module LogStruct
   # but the operation should be allowed to continue (e.g. scrubbing log data.)
   class MultiErrorReporter
     # Class variable to store the selected reporter
-    @reporter = T.let(nil, T.nilable(ErrorReporter))
+    class CallableReporterWrapper
+      extend T::Sig
+
+      sig { params(callable: T.untyped).void }
+      def initialize(callable)
+        @callable = callable
+      end
+
+      sig { returns(T.untyped) }
+      attr_reader :callable
+      alias_method :original, :callable
+
+      sig { params(error: StandardError, context: T.nilable(T::Hash[Symbol, T.untyped]), source: Source).void }
+      def call(error, context, source)
+        case callable_arity
+        when 3
+          callable.call(error, context, source)
+        when 2
+          callable.call(error, context)
+        when 1
+          callable.call(error)
+        else
+          callable.call(error, context, source)
+        end
+      end
+
+      private
+
+      sig { returns(Integer) }
+      def callable_arity
+        callable.respond_to?(:arity) ? callable.arity : -1
+      end
+    end
+
+    ReporterImpl = T.type_alias { T.any(ErrorReporter, CallableReporterWrapper) }
+
+    @reporter_impl = T.let(nil, T.nilable(ReporterImpl))
 
     class << self
       extend T::Sig
 
-      sig { returns(ErrorReporter) }
+      sig { returns(ReporterImpl) }
       def reporter
-        @reporter ||= detect_reporter
+        reporter_impl
       end
 
       # Set the reporter to use (user-friendly API that accepts symbols)
-      sig { params(reporter_type: T.any(ErrorReporter, Symbol)).returns(ErrorReporter) }
+      sig { params(reporter_type: T.any(ErrorReporter, Symbol, Handlers::ErrorReporter)).returns(ReporterImpl) }
       def reporter=(reporter_type)
-        @reporter = case reporter_type
+        @reporter_impl = case reporter_type
         when ErrorReporter
           reporter_type
         when Symbol
-          case reporter_type
-          when :sentry then ErrorReporter::Sentry
-          when :bugsnag then ErrorReporter::Bugsnag
-          when :rollbar then ErrorReporter::Rollbar
-          when :honeybadger then ErrorReporter::Honeybadger
-          when :rails_logger then ErrorReporter::RailsLogger
-          else
-            valid_types = ErrorReporter.values.map { |v| ":#{v.serialize}" }.join(", ")
-            raise ArgumentError, "Unknown reporter type: #{reporter_type}. Valid types are: #{valid_types}"
-          end
+          resolve_symbol_reporter(reporter_type)
+        else
+          wrap_callable_reporter(reporter_type)
         end
       end
 
@@ -69,7 +99,9 @@ def detect_reporter
       sig { params(error: StandardError, context: T::Hash[T.untyped, T.untyped]).void }
       def report_error(error, context = {})
         # Call the appropriate reporter method based on what's available
-        case reporter
+        impl = reporter_impl
+
+        case impl
         when ErrorReporter::Sentry
           report_to_sentry(error, context)
         when ErrorReporter::Bugsnag
@@ -78,13 +110,43 @@ def report_error(error, context = {})
           report_to_rollbar(error, context)
         when ErrorReporter::Honeybadger
           report_to_honeybadger(error, context)
-        else
+        when ErrorReporter::RailsLogger
           fallback_logging(error, context)
+        when CallableReporterWrapper
+          impl.call(error, context, Source::Internal)
         end
       end
 
       private
 
+      sig { returns(ReporterImpl) }
+      def reporter_impl
+        @reporter_impl ||= detect_reporter
+      end
+
+      sig { params(symbol: Symbol).returns(ErrorReporter) }
+      def resolve_symbol_reporter(symbol)
+        case symbol
+        when :sentry then ErrorReporter::Sentry
+        when :bugsnag then ErrorReporter::Bugsnag
+        when :rollbar then ErrorReporter::Rollbar
+        when :honeybadger then ErrorReporter::Honeybadger
+        when :rails_logger then ErrorReporter::RailsLogger
+        else
+          valid_types = ErrorReporter.values.map { |v| ":#{v.serialize}" }.join(", ")
+          raise ArgumentError, "Unknown reporter type: #{symbol}. Valid types are: #{valid_types}"
+        end
+      end
+
+      sig { params(callable: T.untyped).returns(CallableReporterWrapper) }
+      def wrap_callable_reporter(callable)
+        unless callable.respond_to?(:call)
+          raise ArgumentError, "Reporter must respond to #call"
+        end
+
+        CallableReporterWrapper.new(callable)
+      end
+
       # Report to Sentry
       sig { params(error: StandardError, context: T::Hash[T.untyped, T.untyped]).void }
       def report_to_sentry(error, context = {})

lib/log_struct/shared/shared/serialize_common.rb

@@ -3,6 +3,7 @@
 
 require_relative "../../enums/log_field"
 require_relative "../interfaces/common_fields"
+require_relative "../../log/shared/merge_additional_data_fields"
 
 module LogStruct
   module Log
@@ -19,17 +20,19 @@ def serialize(strict = true)
           out = serialize_common(strict)
 
           # Merge event/base fields from the struct-specific hash
-          field_hash = T.unsafe(self).to_h
+          kernel_self = T.cast(self, Kernel)
+          field_hash = T.cast(kernel_self.public_send(:to_h), T::Hash[LogStruct::LogField, T.untyped])
           field_hash.each do |log_field, value|
             next if value.nil?
-            key = T.cast(log_field, LogStruct::LogField).serialize
+            key = log_field.serialize
             out[key] = value.is_a?(::Time) ? value.iso8601 : value
           end
 
           # Merge any additional_data at top level if available
-          if T.unsafe(self).respond_to?(:merge_additional_data_fields)
+          if kernel_self.respond_to?(:merge_additional_data_fields)
             # merge_additional_data_fields expects symbol keys
-            T.unsafe(self).merge_additional_data_fields(out)
+            merge_target = T.cast(self, LogStruct::Log::Shared::MergeAdditionalDataFields)
+            merge_target.merge_additional_data_fields(out)
           end
 
           out

test/log_struct/formatter_test.rb

@@ -175,6 +175,47 @@ def test_process_values_truncates_large_arrays
       assert_equal "... and 10 more items", result.last
     end
 
+    def test_process_values_does_not_process_beyond_limit_for_large_arrays
+      exploding_class = Class.new do
+        attr_reader :index
+
+        def initialize(index, raise_on_touch)
+          @index = index
+          @raise_on_touch = raise_on_touch
+        end
+
+        def touch!
+          raise "Should not touch index #{@index}" if @raise_on_touch
+        end
+      end
+
+      counting_formatter = Class.new(Formatter) do
+        attr_reader :touched_indices
+
+        def initialize
+          super
+          @touched_indices = []
+        end
+
+        def process_values(value, recursion_depth: 0)
+          if value.respond_to?(:touch!)
+            value.touch!
+            @touched_indices << value.index if value.respond_to?(:index)
+          end
+
+          super
+        end
+      end.new
+
+      values = (0...10).map { |i| exploding_class.new(i, false) } +
+        (10...20).map { |i| exploding_class.new(i, true) }
+
+      result = counting_formatter.process_values(values)
+
+      assert_equal 11, result.length
+      assert_equal((0...10).to_a, counting_formatter.touched_indices)
+    end
+
     def test_process_values_handles_recursive_structures
       hash1 = {a: 1}
       hash2 = {b: 2, hash1: hash1}

test/log_struct/multi_error_reporter_test.rb

@@ -11,7 +11,7 @@ def setup
       @context = {user_id: 123, action: "test"}
 
       # Reset the reporter before each test
-      MultiErrorReporter.instance_variable_set(:@reporter, nil)
+      MultiErrorReporter.instance_variable_set(:@reporter_impl, nil)
 
       # Stub stdout to capture output
       @original_stdout = $stdout
@@ -210,6 +210,55 @@ def test_report_error_with_no_service
       end
     end
 
+    def test_reporter_accepts_callable
+      calls = []
+      custom_reporter = lambda do |error, context, source|
+        calls << {
+          error: error,
+          context: context,
+          source: source
+        }
+      end
+
+      MultiErrorReporter.reporter = custom_reporter
+
+      wrapper = MultiErrorReporter.reporter
+
+      assert_respond_to wrapper, :original
+      assert_same custom_reporter, wrapper.original
+
+      MultiErrorReporter.report_error(@exception, @context)
+
+      assert_equal 1, calls.size
+      payload = calls.first
+
+      assert_equal @exception, payload[:error]
+      assert_equal @context, payload[:context]
+      assert_equal Source::Internal, payload[:source]
+    end
+
+    def test_callable_reporter_supports_lower_arity
+      calls = []
+      custom = ->(error, context) { calls << [error, context] }
+
+      MultiErrorReporter.reporter = custom
+      wrapper = MultiErrorReporter.reporter
+
+      assert_kind_of Proc, wrapper.original
+
+      MultiErrorReporter.report_error(@exception, @context)
+
+      assert_equal [[@exception, @context]], calls
+    end
+
+    def test_setting_invalid_reporter_raises
+      error = assert_raises(TypeError) do
+        MultiErrorReporter.reporter = T.unsafe(Object.new)
+      end
+
+      assert_match(/Expected type/, error.message)
+    end
+
     private
 
     def setup_mock_constants