logstruct 0.1.1 → 0.1.3

data/lib/log_struct/log/shrine/exist.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 Exist < T::Struct
-        # typed: strict
-        # frozen_string_literal: true
-
-        extend T::Sig
-
         extend T::Sig
 
         # Shared/common fields
@@ -35,55 +30,22 @@ module LogStruct
         const :level, Level, default: Level::Info
 
         # Event-specific fields
-        const :storage, String
+        const :storage, Symbol
         const :location, String
         const :exist, T.nilable(T::Boolean), 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,
-            exist: T.untyped,
-            additional_data: T.untyped,
-            timestamp: T.untyped).returns(T::Hash[LogStruct::LogField, T.untyped])
-        }
-        def self.build(storage:,
-          location:,
-          exist: 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::Exist] = exist unless exist.nil?
           h
         end
-
-        sig { returns(T::Hash[LogStruct::LogField, T.untyped]) }
-        def to_h
-          self.class.build(
-            storage: storage,
-            location: location,
-            exist: exist,
-            additional_data: additional_data,
-            timestamp: timestamp
-          )
-        end
       end
     end
   end

data/lib/log_struct/log/shrine/metadata.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 Metadata < T::Struct
-        # typed: strict
-        # frozen_string_literal: true
-
-        extend T::Sig
-
         extend T::Sig
 
         # Shared/common fields
@@ -35,55 +30,22 @@ module LogStruct
         const :level, Level, default: Level::Info
 
         # Event-specific fields
-        const :storage, String
-        const :location, String
+        const :storage, Symbol
+        const :location, T.nilable(String), default: nil
         const :metadata, T.nilable(T::Hash[String, T.untyped]), 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,
-            metadata: T.untyped,
-            additional_data: T.untyped,
-            timestamp: T.untyped).returns(T::Hash[LogStruct::LogField, T.untyped])
-        }
-        def self.build(storage:,
-          location:,
-          metadata: 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::Location] = location unless location.nil?
           h[LogField::Metadata] = metadata unless metadata.nil?
           h
         end
-
-        sig { returns(T::Hash[LogStruct::LogField, T.untyped]) }
-        def to_h
-          self.class.build(
-            storage: storage,
-            location: location,
-            metadata: metadata,
-            additional_data: additional_data,
-            timestamp: timestamp
-          )
-        end
       end
     end
   end

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

@@ -54,25 +54,18 @@ module LogStruct
 
       sig { params(args: T.untyped, block: T.nilable(T.proc.returns(T.untyped))).returns(T.untyped) }
       def perform(*args, &block)
-        mark_server_mode!
+        ::LogStruct.server_mode = true
         super
       end
 
       sig { params(server: T.untyped, url: T.nilable(String)).void }
       def print_boot_information(server, url)
-        mark_server_mode!
+        ::LogStruct.server_mode = true
         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)

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
@@ -55,11 +33,7 @@ module LogStruct
 
     # 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
+      is_server = ::LogStruct.server_mode?
       next unless is_server
       begin
         require "log_struct/log/puma"

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