logstruct 0.1.0 → 0.1.1

data/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 @@ module LogStruct
       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 @@ module LogStruct
           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 = {})
@@ -135,11 +197,7 @@ module LogStruct
         return if error.nil?
 
         # Create a proper error log entry
-        error_log = Log::Error.from_exception(
-          Source::LogStruct,
-          error,
-          context
-        )
+        error_log = Log.from_exception(Source::Internal, error, context)
 
         # Use LogStruct.error to properly log the error
         LogStruct.error(error_log)

data/lib/log_struct/param_filters.rb

@@ -3,6 +3,8 @@
 
 require "digest"
 require_relative "hash_utils"
+require_relative "config_struct/filters"
+require_relative "enums/source"
 
 module LogStruct
   # This class contains methods for filtering sensitive data in logs
@@ -12,19 +14,30 @@ module LogStruct
       extend T::Sig
 
       # Check if a key should be filtered based on our defined sensitive keys
-      sig { params(key: T.any(String, Symbol)).returns(T::Boolean) }
-      def should_filter_key?(key)
-        LogStruct.config.filters.filter_keys.include?(key.to_s.downcase.to_sym)
+      sig { params(key: T.untyped, value: T.untyped).returns(T::Boolean) }
+      def should_filter_key?(key, value = nil)
+        filters = LogStruct.config.filters
+        normalized_key = key.to_s
+        normalized_symbol = normalized_key.downcase.to_sym
+
+        return true if filters.filter_keys.include?(normalized_symbol)
+
+        filters.filter_matchers.any? do |matcher|
+          matcher.matches?(normalized_key, value)
+        rescue => e
+          handle_filter_matcher_error(e, matcher, normalized_key)
+          false
+        end
       end
 
       # Check if a key should be hashed rather than completely filtered
-      sig { params(key: T.any(String, Symbol)).returns(T::Boolean) }
+      sig { params(key: T.untyped).returns(T::Boolean) }
       def should_include_string_hash?(key)
         LogStruct.config.filters.filter_keys_with_hashes.include?(key.to_s.downcase.to_sym)
       end
 
       # Convert a value to a filtered summary hash (e.g. { _filtered: { class: "String", ... }})
-      sig { params(key: T.any(String, Symbol), data: T.untyped).returns(T::Hash[Symbol, T.untyped]) }
+      sig { params(key: T.untyped, data: T.untyped).returns(T::Hash[Symbol, T.untyped]) }
       def summarize_json_attribute(key, data)
         case data
         when Hash
@@ -59,12 +72,18 @@ module LogStruct
         return {_class: "Hash", _empty: true} if hash.empty?
 
         # Don't include byte size if hash contains any filtered keys
-        has_sensitive_keys = hash.keys.any? { |key| should_filter_key?(key) }
+        has_sensitive_keys = T.let(false, T::Boolean)
+        normalized_keys = []
+
+        hash.each do |key, value|
+          has_sensitive_keys ||= should_filter_key?(key, value)
+          normalized_keys << normalize_summary_key(key)
+        end
 
         summary = {
           _class: Hash,
           _keys_count: hash.keys.size,
-          _keys: hash.keys.map(&:to_sym).take(10)
+          _keys: normalized_keys.take(10)
         }
 
         # Only add byte size if no sensitive keys are present
@@ -84,6 +103,30 @@ module LogStruct
           _bytes: array.to_json.bytesize
         }
       end
+
+      private
+
+      sig { params(key: T.any(String, Symbol, Integer, T.untyped)).returns(T.any(Symbol, String)) }
+      def normalize_summary_key(key)
+        if key.is_a?(Symbol)
+          key
+        elsif key.respond_to?(:to_sym)
+          key.to_sym
+        else
+          key.to_s
+        end
+      rescue
+        key.to_s
+      end
+
+      sig { params(error: StandardError, matcher: ConfigStruct::FilterMatcher, key: String).void }
+      def handle_filter_matcher_error(error, matcher, key)
+        context = {
+          matcher: matcher.label,
+          key: key
+        }
+        LogStruct.handle_exception(error, source: Source::Internal, context: context)
+      end
     end
   end
 end

data/lib/log_struct/rails_boot_banner_silencer.rb

@@ -0,0 +1,123 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+
+module LogStruct
+  module RailsBootBannerSilencer
+    extend T::Sig
+
+    @installed = T.let(false, T::Boolean)
+
+    sig { void }
+    def self.install!
+      return if @installed
+      @installed = true
+
+      return unless ARGV.include?("server")
+      patch!
+    end
+
+    sig { returns(T::Boolean) }
+    def self.patch!
+      begin
+        require "rails/command"
+        require "rails/commands/server/server_command"
+      rescue LoadError
+        # Best-effort – if Rails isn't available yet we'll try again later
+        return false
+      end
+
+      server_command = T.let(nil, T.untyped)
+      # rubocop:disable Sorbet/ConstantsFromStrings
+      begin
+        server_command = ::Object.const_get("Rails::Command::ServerCommand")
+      rescue NameError
+        server_command = nil
+      end
+      # rubocop:enable Sorbet/ConstantsFromStrings
+      return false unless server_command
+
+      patch_server_command(server_command)
+      true
+    end
+
+    sig { params(server_command: T.untyped).void }
+    def self.patch_server_command(server_command)
+      return if server_command <= ServerCommandSilencer
+
+      server_command.prepend(ServerCommandSilencer)
+    end
+
+    module ServerCommandSilencer
+      extend T::Sig
+
+      sig { params(args: T.untyped, block: T.nilable(T.proc.returns(T.untyped))).returns(T.untyped) }
+      def perform(*args, &block)
+        mark_server_mode!
+        super
+      end
+
+      sig { params(server: T.untyped, url: T.nilable(String)).void }
+      def print_boot_information(server, url)
+        mark_server_mode!
+        consume_boot_banner(server, url)
+      end
+
+      private
+
+      sig { void }
+      def mark_server_mode!
+        ::LogStruct.instance_variable_set(:@server_mode, true)
+      rescue
+        # Ignore – server mode is best-effort
+      end
+
+      sig { params(server: T.untyped, url: T.nilable(String)).void }
+      def consume_boot_banner(server, url)
+        return unless defined?(::LogStruct::Integrations::Puma)
+
+        begin
+          ::LogStruct::Integrations::Puma.emit_boot_if_needed!
+        rescue => e
+          ::LogStruct::Integrations::Puma.handle_integration_error(e)
+        end
+
+        begin
+          model = ::ActiveSupport::Inflector.demodulize(server)
+        rescue
+          model = "Puma"
+        end
+
+        lines = [
+          "=> Booting #{model}",
+          build_rails_banner_line(url),
+          "=> Run `#{lookup_executable} --help` for more startup options"
+        ]
+
+        lines.each do |line|
+          ::LogStruct::Integrations::Puma.process_line(line)
+        rescue => e
+          ::LogStruct::Integrations::Puma.handle_integration_error(e)
+        end
+      end
+
+      sig { params(url: T.nilable(String)).returns(String) }
+      def build_rails_banner_line(url)
+        suffix = url ? " #{url}" : ""
+        "=> Rails #{::Rails.version} application starting in #{::Rails.env}#{suffix}"
+      rescue
+        "=> Rails application starting"
+      end
+
+      sig { returns(String) }
+      def lookup_executable
+        return "rails" unless T.unsafe(self).respond_to?(:executable, true)
+
+        T.cast(T.unsafe(self).send(:executable), String)
+      rescue
+        "rails"
+      end
+    end
+  end
+end

data/lib/log_struct/railtie.rb

@@ -5,14 +5,37 @@ require "rails"
 require "semantic_logger"
 require_relative "formatter"
 require_relative "semantic_logger/setup"
+require_relative "integrations"
 
 module LogStruct
   # Railtie to integrate with Rails
   class Railtie < ::Rails::Railtie
+    # Ensure test hosts are allowed early enough for middleware build
+    initializer "logstruct.allow_test_hosts", before: :build_middleware_stack do |app|
+      if ::Rails.env.test? && app.config.respond_to?(:hosts)
+        begin
+          app.config.hosts << /.*\z/
+        rescue
+          # best-effort
+        end
+        begin
+          app.config.middleware.delete(::ActionDispatch::HostAuthorization)
+        rescue
+          # best-effort
+        end
+      end
+    end
+
+    # After ActionDispatch is configured, remove HostAuthorization in test to prevent 403s
+    # (No late deletion needed; handled above before middleware stack is built)
+
     # Configure early, right after logger initialization
     initializer "logstruct.configure_logger", after: :initialize_logger do |app|
       next unless LogStruct.enabled?
 
+      # Apply TaggedLogging monkey patch only when enabled
+      require_relative "monkey_patches/active_support/tagged_logging/formatter"
+
       # Use SemanticLogger for powerful logging features
       LogStruct::SemanticLogger::Setup.configure_semantic_logger(app)
     end
@@ -26,6 +49,54 @@ module LogStruct
 
       # Set up all integrations
       Integrations.setup_integrations
+
+      # Note: Host allowances are managed by the test app itself.
     end
+
+    # Emit Puma lifecycle logs when running `rails server`
+    initializer "logstruct.puma_lifecycle", after: "logstruct.configure_logger" do
+      begin
+        is_server = ::LogStruct.instance_variable_defined?(:@server_mode) && ::LogStruct.instance_variable_get(:@server_mode)
+      rescue
+        is_server = false
+      end
+      next unless is_server
+      begin
+        require "log_struct/log/puma"
+        port = T.let(nil, T.nilable(String))
+        ARGV.each_with_index do |arg, idx|
+          if arg == "-p" || arg == "--port"
+            port = ARGV[idx + 1]
+            break
+          elsif arg.start_with?("--port=")
+            port = arg.split("=", 2)[1]
+            break
+          end
+        end
+        started = LogStruct::Log::Puma::Start.new(
+          mode: "single",
+          environment: (defined?(::Rails) && ::Rails.respond_to?(:env)) ? ::Rails.env : nil,
+          process_id: Process.pid,
+          listening_addresses: port ? ["tcp://127.0.0.1:#{port}"] : nil
+        )
+        begin
+          warn("[logstruct] puma lifecycle init")
+        rescue
+        end
+        LogStruct.info(started)
+
+        at_exit do
+          shutdown = LogStruct::Log::Puma::Shutdown.new(
+            process_id: Process.pid
+          )
+          LogStruct.info(shutdown)
+        end
+      rescue
+        # best-effort
+      end
+    end
+
+    # Delegate integration initializers to Integrations module
+    LogStruct::Integrations.setup_initializers(self)
   end
 end

data/lib/log_struct/semantic_logger/formatter.rb

@@ -62,7 +62,7 @@ module LogStruct
       sig { params(log: ::SemanticLogger::Log, logger: T.untyped).returns(String) }
       def call(log, logger)
         # Handle LogStruct types specially - they get wrapped in payload hash by SemanticLogger
-        if log.payload.is_a?(Hash) && log.payload[:payload].is_a?(LogStruct::Log::Interfaces::CommonFields)
+        json = if log.payload.is_a?(Hash) && log.payload[:payload].is_a?(LogStruct::Log::Interfaces::CommonFields)
           # Use our formatter to process LogStruct types
           @logstruct_formatter.call(log.level, log.time, log.name, log.payload[:payload])
         elsif log.payload.is_a?(LogStruct::Log::Interfaces::CommonFields)
@@ -77,12 +77,14 @@ module LogStruct
         else
           # For plain messages, create a Plain log entry
           message_data = log.payload || log.message
-          plain_log = LogStruct::Log::Plain.new(
+          plain_log = ::LogStruct::Log::Plain.new(
             message: message_data,
             timestamp: log.time
           )
           @logstruct_formatter.call(log.level, log.time, log.name, plain_log)
         end
+        # SemanticLogger appenders typically add their own newline. Avoid double newlines by stripping ours.
+        json.end_with?("\n") ? json.chomp : json
       end
 
       private

data/lib/log_struct/semantic_logger/setup.rb

@@ -106,7 +106,7 @@ module LogStruct
         elsif Rails.env.production?
           :info
         elsif Rails.env.test?
-          :warn
+          :debug
         else
           :debug
         end
@@ -119,17 +119,32 @@ module LogStruct
         # Determine output destination
         io = determine_output(app)
 
-        if Rails.env.development? && config.integrations.enable_color_output
-          # Use our colorized LogStruct formatter for development
-          ::SemanticLogger.add_appender(
-            io: io,
-            formatter: LogStruct::SemanticLogger::ColorFormatter.new(
-              color_map: config.integrations.color_map
-            ),
-            filter: determine_filter
-          )
+        if Rails.env.development?
+          if config.prefer_json_in_development
+            # Default to production-style JSON in development when enabled
+            ::SemanticLogger.add_appender(
+              io: io,
+              formatter: LogStruct::SemanticLogger::Formatter.new,
+              filter: determine_filter
+            )
+          elsif config.enable_color_output
+            # Opt-in colorful human formatter in development
+            ::SemanticLogger.add_appender(
+              io: io,
+              formatter: LogStruct::SemanticLogger::ColorFormatter.new(
+                color_map: config.color_map
+              ),
+              filter: determine_filter
+            )
+          else
+            ::SemanticLogger.add_appender(
+              io: io,
+              formatter: LogStruct::SemanticLogger::Formatter.new,
+              filter: determine_filter
+            )
+          end
         else
-          # Use our custom JSON formatter
+          # Use our custom JSON formatter in non-development environments
           ::SemanticLogger.add_appender(
             io: io,
             formatter: LogStruct::SemanticLogger::Formatter.new,
@@ -147,15 +162,16 @@ module LogStruct
         end
       end
 
-      sig { params(app: T.untyped).returns(T.any(IO, StringIO)) }
+      sig { params(app: T.untyped).returns(T.untyped) }
       def self.determine_output(app)
-        if ENV["RAILS_LOG_TO_STDOUT"].present?
-          $stdout
-        elsif Rails.env.test?
-          # Use StringIO for tests to avoid cluttering test output
+        # Always honor explicit STDOUT directive, even in test, or when LogStruct is enabled via env
+        return $stdout if ENV["RAILS_LOG_TO_STDOUT"].present? || ENV["LOGSTRUCT_ENABLED"].to_s.strip.downcase == "true"
+
+        if Rails.env.test?
+          # Default to StringIO to keep test output clean unless STDOUT is requested
           StringIO.new
         else
-          # Prefer file logging when not explicitly configured for STDOUT
+          # Default to STDOUT for app logs
           $stdout
         end
       end
@@ -164,7 +180,7 @@ module LogStruct
       def self.determine_filter
         # Filter out noisy loggers if configured
         config = LogStruct.config
-        return nil unless config.integrations.filter_noisy_loggers
+        return nil unless config.filter_noisy_loggers
 
         # Common noisy loggers to filter
         /\A(ActionView|ActionController::RoutingError|ActiveRecord::SchemaMigration)/

data/lib/log_struct/shared/interfaces/additional_data_field.rb

@@ -0,0 +1,22 @@
+# typed: strict
+# frozen_string_literal: true
+
+# Moved from lib/log_struct/log/interfaces/additional_data_field.rb
+module LogStruct
+  module Log
+    module Interfaces
+      module AdditionalDataField
+        extend T::Sig
+        extend T::Helpers
+
+        interface!
+
+        requires_ancestor { T::Struct }
+
+        sig { abstract.returns(T.nilable(T::Hash[T.any(String, Symbol), T.untyped])) }
+        def additional_data
+        end
+      end
+    end
+  end
+end

data/lib/log_struct/shared/interfaces/common_fields.rb

@@ -0,0 +1,39 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative "../../enums/source"
+require_relative "../../enums/event"
+require_relative "../../enums/level"
+
+module LogStruct
+  module Log
+    module Interfaces
+      module CommonFields
+        extend T::Sig
+        extend T::Helpers
+
+        interface!
+
+        sig { abstract.returns(Source) }
+        def source
+        end
+
+        sig { abstract.returns(Event) }
+        def event
+        end
+
+        sig { abstract.returns(Level) }
+        def level
+        end
+
+        sig { abstract.returns(Time) }
+        def timestamp
+        end
+
+        sig { abstract.params(strict: T::Boolean).returns(T::Hash[Symbol, T.untyped]) }
+        def serialize(strict = true)
+        end
+      end
+    end
+  end
+end

data/lib/log_struct/shared/interfaces/public_common_fields.rb

@@ -0,0 +1,29 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative "../../enums/level"
+
+module LogStruct
+  module Log
+    module Interfaces
+      module PublicCommonFields
+        extend T::Sig
+        extend T::Helpers
+
+        interface!
+
+        sig { abstract.returns(Level) }
+        def level
+        end
+
+        sig { abstract.returns(Time) }
+        def timestamp
+        end
+
+        sig { abstract.params(strict: T::Boolean).returns(T::Hash[Symbol, T.untyped]) }
+        def serialize(strict = true)
+        end
+      end
+    end
+  end
+end