logstruct 0.1.2 → 0.1.3

data/lib/log_struct/log/shrine/upload.rb

@@ -9,9 +9,9 @@
 require "log_struct/shared/interfaces/common_fields"
 require "log_struct/shared/interfaces/additional_data_field"
 require "log_struct/shared/interfaces/request_fields"
-require "log_struct/shared/shared/serialize_common"
-require "log_struct/shared/shared/merge_additional_data_fields"
-require "log_struct/shared/shared/add_request_fields"
+require "log_struct/shared/serialize_common"
+require "log_struct/shared/merge_additional_data_fields"
+require "log_struct/shared/add_request_fields"
 require_relative "../../enums/source"
 require_relative "../../enums/event"
 require_relative "../../enums/level"
@@ -21,11 +21,6 @@ module LogStruct
   module Log
     class Shrine
       class Upload < T::Struct
-        # typed: strict
-        # frozen_string_literal: true
-
-        extend T::Sig
-
         extend T::Sig
 
         # Shared/common fields
@@ -35,48 +30,20 @@ module LogStruct
         const :level, Level, default: Level::Info
 
         # Event-specific fields
-        const :storage, String
+        const :storage, Symbol
         const :location, String
         const :upload_options, T.nilable(T::Hash[Symbol, T.untyped]), default: nil
         const :options, T.nilable(T::Hash[Symbol, T.untyped]), default: nil
         const :uploader, T.nilable(String), default: nil
         const :duration_ms, T.nilable(Float), default: nil
 
-        # Additional data
-        include LogStruct::Log::Interfaces::AdditionalDataField
-        const :additional_data, T.nilable(T::Hash[T.any(String, Symbol), T.untyped]), default: nil
-        include LogStruct::Log::Shared::MergeAdditionalDataFields
-
-        # Request fields (optional)
-
         # Serialize shared fields
         include LogStruct::Log::Interfaces::CommonFields
         include LogStruct::Log::Shared::SerializeCommon
 
         sig { returns(T::Hash[LogStruct::LogField, T.untyped]) }
-        def self.base_hash
-          {}
-        end
-
-        sig {
-          params(storage: T.untyped,
-            location: T.untyped,
-            upload_options: T.untyped,
-            options: T.untyped,
-            uploader: T.untyped,
-            duration_ms: T.untyped,
-            additional_data: T.untyped,
-            timestamp: T.untyped).returns(T::Hash[LogStruct::LogField, T.untyped])
-        }
-        def self.build(storage:,
-          location:,
-          upload_options: nil,
-          options: nil,
-          uploader: nil,
-          duration_ms: nil,
-          additional_data: nil,
-          timestamp: Time.now)
-          h = base_hash
+        def to_h
+          h = T.let({}, T::Hash[LogStruct::LogField, T.untyped])
           h[LogField::Storage] = storage
           h[LogField::Location] = location
           h[LogField::UploadOptions] = upload_options unless upload_options.nil?
@@ -85,20 +52,6 @@ module LogStruct
           h[LogField::DurationMs] = duration_ms unless duration_ms.nil?
           h
         end
-
-        sig { returns(T::Hash[LogStruct::LogField, T.untyped]) }
-        def to_h
-          self.class.build(
-            storage: storage,
-            location: location,
-            upload_options: upload_options,
-            options: options,
-            uploader: uploader,
-            duration_ms: duration_ms,
-            additional_data: additional_data,
-            timestamp: timestamp
-          )
-        end
       end
     end
   end

data/lib/log_struct/log/sidekiq.rb

@@ -9,9 +9,9 @@
 require "log_struct/shared/interfaces/common_fields"
 require "log_struct/shared/interfaces/additional_data_field"
 require "log_struct/shared/interfaces/request_fields"
-require "log_struct/shared/shared/serialize_common"
-require "log_struct/shared/shared/merge_additional_data_fields"
-require "log_struct/shared/shared/add_request_fields"
+require "log_struct/shared/serialize_common"
+require "log_struct/shared/merge_additional_data_fields"
+require "log_struct/shared/add_request_fields"
 require_relative "../enums/source"
 require_relative "../enums/event"
 require_relative "../enums/level"
@@ -20,11 +20,6 @@ require_relative "../enums/log_field"
 module LogStruct
   module Log
     class Sidekiq < T::Struct
-      # typed: strict
-      # frozen_string_literal: true
-
-      extend T::Sig
-
       extend T::Sig
 
       # Shared/common fields
@@ -39,51 +34,19 @@ module LogStruct
       const :process_id, T.nilable(Integer), default: nil
       const :thread_id, T.nilable(T.any(Integer, String)), default: nil
 
-      # Additional data
-
-      # Request fields (optional)
-
       # Serialize shared fields
       include LogStruct::Log::Interfaces::CommonFields
       include LogStruct::Log::Shared::SerializeCommon
 
       sig { returns(T::Hash[LogStruct::LogField, T.untyped]) }
-      def self.base_hash
-        {}
-      end
-
-      sig {
-        params(message: T.untyped,
-          context: T.untyped,
-          process_id: T.untyped,
-          thread_id: T.untyped,
-          additional_data: T.untyped,
-          timestamp: T.untyped).returns(T::Hash[LogStruct::LogField, T.untyped])
-      }
-      def self.build(message: nil,
-        context: nil,
-        process_id: nil,
-        thread_id: nil,
-        additional_data: nil,
-        timestamp: Time.now)
-        h = base_hash
+      def to_h
+        h = T.let({}, T::Hash[LogStruct::LogField, T.untyped])
         h[LogField::Message] = message unless message.nil?
         h[LogField::Context] = context unless context.nil?
         h[LogField::ProcessId] = process_id unless process_id.nil?
         h[LogField::ThreadId] = thread_id unless thread_id.nil?
         h
       end
-
-      sig { returns(T::Hash[LogStruct::LogField, T.untyped]) }
-      def to_h
-        self.class.build(
-          message: message,
-          context: context,
-          process_id: process_id,
-          thread_id: thread_id,
-          timestamp: timestamp
-        )
-      end
     end
   end
 end

data/lib/log_struct/log/sql.rb

@@ -9,9 +9,9 @@
 require "log_struct/shared/interfaces/common_fields"
 require "log_struct/shared/interfaces/additional_data_field"
 require "log_struct/shared/interfaces/request_fields"
-require "log_struct/shared/shared/serialize_common"
-require "log_struct/shared/shared/merge_additional_data_fields"
-require "log_struct/shared/shared/add_request_fields"
+require "log_struct/shared/serialize_common"
+require "log_struct/shared/merge_additional_data_fields"
+require "log_struct/shared/add_request_fields"
 require_relative "../enums/source"
 require_relative "../enums/event"
 require_relative "../enums/level"
@@ -20,11 +20,6 @@ require_relative "../enums/log_field"
 module LogStruct
   module Log
     class SQL < T::Struct
-      # typed: strict
-      # frozen_string_literal: true
-
-      extend T::Sig
-
       extend T::Sig
 
       # Shared/common fields
@@ -52,48 +47,13 @@ module LogStruct
       const :additional_data, T.nilable(T::Hash[T.any(String, Symbol), T.untyped]), default: nil
       include LogStruct::Log::Shared::MergeAdditionalDataFields
 
-      # Request fields (optional)
-
       # Serialize shared fields
       include LogStruct::Log::Interfaces::CommonFields
       include LogStruct::Log::Shared::SerializeCommon
 
       sig { returns(T::Hash[LogStruct::LogField, T.untyped]) }
-      def self.base_hash
-        {}
-      end
-
-      sig {
-        params(message: T.untyped,
-          sql: T.untyped,
-          name: T.untyped,
-          duration_ms: T.untyped,
-          row_count: T.untyped,
-          adapter: T.untyped,
-          bind_params: T.untyped,
-          database_name: T.untyped,
-          connection_pool_size: T.untyped,
-          active_connections: T.untyped,
-          operation_type: T.untyped,
-          table_names: T.untyped,
-          additional_data: T.untyped,
-          timestamp: T.untyped).returns(T::Hash[LogStruct::LogField, T.untyped])
-      }
-      def self.build(message:,
-        sql:,
-        name:,
-        duration_ms:,
-        row_count: nil,
-        adapter: nil,
-        bind_params: nil,
-        database_name: nil,
-        connection_pool_size: nil,
-        active_connections: nil,
-        operation_type: nil,
-        table_names: nil,
-        additional_data: nil,
-        timestamp: Time.now)
-        h = base_hash
+      def to_h
+        h = T.let({}, T::Hash[LogStruct::LogField, T.untyped])
         h[LogField::Message] = message
         h[LogField::Sql] = sql
         h[LogField::Name] = name
@@ -108,26 +68,6 @@ module LogStruct
         h[LogField::TableNames] = table_names unless table_names.nil?
         h
       end
-
-      sig { returns(T::Hash[LogStruct::LogField, T.untyped]) }
-      def to_h
-        self.class.build(
-          message: message,
-          sql: sql,
-          name: name,
-          duration_ms: duration_ms,
-          row_count: row_count,
-          adapter: adapter,
-          bind_params: bind_params,
-          database_name: database_name,
-          connection_pool_size: connection_pool_size,
-          active_connections: active_connections,
-          operation_type: operation_type,
-          table_names: table_names,
-          additional_data: additional_data,
-          timestamp: timestamp
-        )
-      end
     end
   end
 end

data/lib/log_struct/log.rb

@@ -7,7 +7,7 @@ require_relative "enums/event"
 require_relative "enums/level"
 require_relative "enums/log_field"
 require_relative "log/interfaces/public_common_fields"
-require_relative "log/shared/serialize_common_public"
+require_relative "shared/serialize_common_public"
 
 # Dynamically require all top-level log structs under log/*
 # Nested per-event files are required by their parent files.
@@ -31,7 +31,7 @@ module LogStruct
     def self.from_exception(source, ex, additional_data = {}, timestamp = Time.now)
       LogStruct::Log::Error.new(
         source: source,
-        err_class: ex.class,
+        error_class: ex.class,
         message: ex.message,
         backtrace: ex.backtrace,
         additional_data: additional_data,

data/lib/log_struct/monkey_patches/active_support/tagged_logging/formatter.rb

@@ -8,6 +8,16 @@ require "active_support/tagged_logging"
 # directly into the hash instead of being prepended as strings
 module ActiveSupport
   module TaggedLogging
+    extend T::Sig
+
+    # Add class-level current_tags method for compatibility with Rails code
+    # that expects to call ActiveSupport::TaggedLogging.current_tags
+    # Use thread-local storage directly like Rails does internally
+    sig { returns(T::Array[T.any(String, Symbol)]) }
+    def self.current_tags
+      Thread.current[:activesupport_tagged_logging_tags] || []
+    end
+
     module FormatterExtension
       extend T::Sig
       extend T::Helpers
@@ -23,7 +33,8 @@ module ActiveSupport
         data = {message: data.to_s} unless data.is_a?(Hash)
 
         # Add current tags to the hash if present
-        tags = current_tags
+        # Use thread-local storage directly as fallback if current_tags method doesn't exist
+        tags = T.unsafe(self).respond_to?(:current_tags) ? current_tags : (Thread.current[:activesupport_tagged_logging_tags] || [])
         data[:tags] = tags if tags.present?
 
         # Call the original formatter with our enhanced data

data/lib/log_struct/railtie.rb

@@ -10,32 +10,10 @@ 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

data/lib/log_struct/semantic_logger/concerns/log_methods.rb

@@ -0,0 +1,100 @@
+# typed: strict
+# frozen_string_literal: true
+
+module LogStruct
+  module SemanticLogger
+    module Concerns
+      module LogMethods
+        extend T::Sig
+        extend T::Helpers
+        requires_ancestor { LogStruct::SemanticLogger::Logger }
+
+        # Override log methods to handle LogStruct types and broadcast
+        sig { params(message: T.untyped, payload: T.untyped, block: T.nilable(T.proc.returns(String))).returns(T::Boolean) }
+        def debug(message = nil, payload = nil, &block)
+          instrument_log(message, :debug)
+          result = if message.is_a?(LogStruct::Log::Interfaces::CommonFields) || message.is_a?(T::Struct) || message.is_a?(Hash)
+            super(nil, payload: message, &block)
+          else
+            super
+          end
+          broadcasts.each do |logger|
+            next unless logger.respond_to?(:debug)
+            message.is_a?(String) ? logger.debug(message) : (logger.debug(&block) if block)
+          end
+          result
+        end
+
+        sig { params(message: T.untyped, payload: T.untyped, block: T.nilable(T.proc.returns(String))).returns(T::Boolean) }
+        def info(message = nil, payload = nil, &block)
+          instrument_log(message, :info)
+          result = if message.is_a?(LogStruct::Log::Interfaces::CommonFields) || message.is_a?(T::Struct) || message.is_a?(Hash)
+            super(nil, payload: message, &block)
+          else
+            super
+          end
+          broadcasts.each do |logger|
+            next unless logger.respond_to?(:info)
+            message.is_a?(String) ? logger.info(message) : (logger.info(&block) if block)
+          end
+          result
+        end
+
+        sig { params(message: T.untyped, payload: T.untyped, block: T.nilable(T.proc.returns(String))).returns(T::Boolean) }
+        def warn(message = nil, payload = nil, &block)
+          instrument_log(message, :warn)
+          result = if message.is_a?(LogStruct::Log::Interfaces::CommonFields) || message.is_a?(T::Struct) || message.is_a?(Hash)
+            super(nil, payload: message, &block)
+          else
+            super
+          end
+          broadcasts.each do |logger|
+            next unless logger.respond_to?(:warn)
+            message.is_a?(String) ? logger.warn(message) : (logger.warn(&block) if block)
+          end
+          result
+        end
+
+        sig { params(message: T.untyped, payload: T.untyped, block: T.nilable(T.proc.returns(String))).returns(T::Boolean) }
+        def error(message = nil, payload = nil, &block)
+          instrument_log(message, :error)
+          result = if message.is_a?(LogStruct::Log::Interfaces::CommonFields) || message.is_a?(T::Struct) || message.is_a?(Hash)
+            super(nil, payload: message, &block)
+          else
+            super
+          end
+          broadcasts.each do |logger|
+            next unless logger.respond_to?(:error)
+            message.is_a?(String) ? logger.error(message) : (logger.error(&block) if block)
+          end
+          result
+        end
+
+        sig { params(message: T.untyped, payload: T.untyped, block: T.nilable(T.proc.returns(String))).returns(T::Boolean) }
+        def fatal(message = nil, payload = nil, &block)
+          instrument_log(message, :fatal)
+          result = if message.is_a?(LogStruct::Log::Interfaces::CommonFields) || message.is_a?(T::Struct) || message.is_a?(Hash)
+            super(nil, payload: message, &block)
+          else
+            super
+          end
+          broadcasts.each do |logger|
+            next unless logger.respond_to?(:fatal)
+            message.is_a?(String) ? logger.fatal(message) : (logger.fatal(&block) if block)
+          end
+          result
+        end
+
+        private
+
+        # Instrument log events for subscribers
+        sig { params(message: T.untyped, level: Symbol).void }
+        def instrument_log(message, level)
+          return unless message.is_a?(LogStruct::Log::Interfaces::CommonFields) || message.is_a?(T::Struct)
+
+          ::ActiveSupport::Notifications.instrument("log.logstruct", log: message, level: level)
+        end
+      end
+    end
+  end
+end

data/lib/log_struct/semantic_logger/logger.rb

@@ -2,6 +2,7 @@
 # frozen_string_literal: true
 
 require "semantic_logger"
+require_relative "concerns/log_methods"
 
 module LogStruct
   module SemanticLogger
@@ -69,25 +70,37 @@ module LogStruct
       def initialize(name = "Application", level: nil, filter: nil)
         # SemanticLogger::Logger expects positional arguments, not named arguments
         super(name, level, filter)
+        # T.untyped because users can pass any logger: ::Logger, ActiveSupport::Logger,
+        # custom loggers (FakeLogger in tests), or third-party loggers
+        @broadcasts = T.let([], T::Array[T.untyped])
+        # ActiveJob expects logger.formatter to exist and respond to current_tags
+        @formatter = T.let(FormatterProxy.new, FormatterProxy)
       end
 
-      # Override log methods to handle LogStruct types
-      %i[debug info warn error fatal].each do |level|
-        define_method(level) do |message = nil, payload = nil, &block|
-          # If message is a LogStruct type, use it as payload
-          if message.is_a?(LogStruct::Log::Interfaces::CommonFields) ||
-              message.is_a?(T::Struct) ||
-              message.is_a?(Hash)
-            payload = message
-            message = nil
-            super(message, payload: payload, &block)
-          else
-            # For plain string messages, pass them through normally
-            super(message, payload, &block)
-          end
-        end
+      # ActiveSupport::BroadcastLogger compatibility
+      # These methods allow Rails.logger to broadcast to multiple loggers
+      sig { returns(T::Array[T.untyped]) }
+      attr_reader :broadcasts
+
+      # ActiveJob compatibility - expects logger.formatter.current_tags
+      sig { returns(FormatterProxy) }
+      attr_reader :formatter
+
+      # T.untyped for logger param because we accept any logger-like object:
+      # ::Logger, ActiveSupport::Logger, test doubles, etc.
+      sig { params(logger: T.untyped).returns(T.untyped) }
+      def broadcast_to(logger)
+        @broadcasts << logger
+        logger
+      end
+
+      sig { params(logger: T.untyped).void }
+      def stop_broadcasting_to(logger)
+        @broadcasts.delete(logger)
       end
 
+      include Concerns::LogMethods
+
       # Support for tagged logging
       sig { params(tags: T.untyped, block: T.proc.returns(T.untyped)).returns(T.untyped) }
       def tagged(*tags, &block)
@@ -124,6 +137,24 @@ module LogStruct
       def pop_tags(count = 1)
         ::SemanticLogger.pop_tags(count)
       end
+
+      # Support for << operator (used by RailsLogSplitter)
+      sig { params(msg: String).returns(T.self_type) }
+      def <<(msg)
+        info(msg)
+        @broadcasts.each { |logger| logger << msg if logger.respond_to?(:<<) }
+        self
+      end
+    end
+
+    # Proxy object to provide ActiveJob-compatible formatter interface
+    class FormatterProxy
+      extend T::Sig
+
+      sig { returns(T::Array[T.any(String, Symbol)]) }
+      def current_tags
+        Thread.current[:activesupport_tagged_logging_tags] || []
+      end
     end
   end
 end

data/lib/log_struct/semantic_logger/setup.rb

@@ -152,8 +152,8 @@ module LogStruct
           )
         end
 
-        # Add file appender if configured and not already logging to STDOUT/StringIO
-        if app.config.paths["log"].first && io != $stdout && !io.is_a?(StringIO)
+        # Add file appender if Rails has a log path configured (normal Rails behavior)
+        if app.config.paths["log"].first
           ::SemanticLogger.add_appender(
             file_name: app.config.paths["log"].first,
             formatter: LogStruct::SemanticLogger::Formatter.new,
@@ -164,14 +164,14 @@ module LogStruct
 
       sig { params(app: T.untyped).returns(T.untyped) }
       def self.determine_output(app)
-        # 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"
+        # Always honor explicit STDOUT directive
+        return $stdout if ENV["RAILS_LOG_TO_STDOUT"].present?
 
         if Rails.env.test?
-          # Default to StringIO to keep test output clean unless STDOUT is requested
+          # Use StringIO in test to keep stdout clean
           StringIO.new
         else
-          # Default to STDOUT for app logs
+          # Use STDOUT for app logs in dev/production
           $stdout
         end
       end
@@ -222,7 +222,11 @@ module LogStruct
         # Also replace various component loggers
         ActiveRecord::Base.logger = logger if defined?(ActiveRecord::Base)
         ActionController::Base.logger = logger if defined?(ActionController::Base)
-        ActionMailer::Base.logger = logger if defined?(ActionMailer::Base)
+        if defined?(ActionMailer::Base)
+          ActionMailer::Base.logger = logger
+          # Ensure ActionMailer.logger is also set (it might be accessed directly)
+          T.unsafe(::ActionMailer).logger = logger if T.unsafe(::ActionMailer).respond_to?(:logger=)
+        end
         ActiveJob::Base.logger = logger if defined?(ActiveJob::Base)
         ActionView::Base.logger = logger if defined?(ActionView::Base)
         ActionCable.server.config.logger = logger if defined?(ActionCable)

data/lib/log_struct/shared/{shared/add_request_fields.rb → add_request_fields.rb}

@@ -1,8 +1,8 @@
 # typed: strict
 # frozen_string_literal: true
 
-require_relative "../../enums/log_field"
-require_relative "../interfaces/request_fields"
+require_relative "../enums/log_field"
+require_relative "interfaces/request_fields"
 
 module LogStruct
   module Log

data/lib/log_struct/shared/{shared/merge_additional_data_fields.rb → merge_additional_data_fields.rb}

@@ -1,7 +1,7 @@
 # typed: strict
 # frozen_string_literal: true
 
-require_relative "../interfaces/additional_data_field"
+require_relative "interfaces/additional_data_field"
 
 module LogStruct
   module Log

data/lib/log_struct/shared/{shared/serialize_common.rb → serialize_common.rb}

@@ -1,9 +1,9 @@
 # typed: strict
 # frozen_string_literal: true
 
-require_relative "../../enums/log_field"
-require_relative "../interfaces/common_fields"
-require_relative "../../log/shared/merge_additional_data_fields"
+require_relative "../enums/log_field"
+require_relative "interfaces/common_fields"
+require_relative "merge_additional_data_fields"
 
 module LogStruct
   module Log
@@ -25,6 +25,12 @@ module LogStruct
           field_hash.each do |log_field, value|
             next if value.nil?
             key = log_field.serialize
+
+            # Limit backtrace to first 5 lines
+            if key == :backtrace && value.is_a?(Array)
+              value = value.first(5)
+            end
+
             out[key] = value.is_a?(::Time) ? value.iso8601 : value
           end
 

data/lib/log_struct/{log/shared → shared}/serialize_common_public.rb

@@ -1,8 +1,8 @@
 # typed: strict
 # frozen_string_literal: true
 
-require_relative "../../enums/log_field"
-require_relative "../interfaces/public_common_fields"
+require_relative "../enums/log_field"
+require_relative "interfaces/public_common_fields"
 
 module LogStruct
   module Log

data/lib/log_struct/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module LogStruct
-  VERSION = "0.1.2"
+  VERSION = "0.1.3"
 end

data/lib/log_struct.rb

@@ -22,6 +22,9 @@ require "log_struct/semantic_logger/logger"
 require "log_struct/semantic_logger/setup"
 require "log_struct/rails_boot_banner_silencer"
 
+# Monkey patches for Rails compatibility
+require "log_struct/monkey_patches/active_support/tagged_logging/formatter"
+
 module LogStruct
   extend T::Sig
 
@@ -44,7 +47,7 @@ module LogStruct
   end
 
   # Set enabled at require time based on current Rails environment.
-  # (Users can disable or enable LogStruct later in an initializer.)
+  # (Users can override this in their initializer which runs before the Railtie checks enabled)
   set_enabled_from_rails_env!
 
   # Silence Rails boot banners for cleaner server output