logstruct 0.1.6 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 39ad690f2ccb74a697feebdd40978e5cc99fd0c78d4ae550611c01d18aeb56fd
-  data.tar.gz: 372f2cceb00b8def2054194161f234b8bd193005249c28490442cc0dc59de370
+  metadata.gz: 3634f56776f895f97747c8165065651aca55098520469624f73f2d75b090f33c
+  data.tar.gz: c29661ad9e8044bad356a5a699f9aaed053c55ec124226784c60dd78655e794f
 SHA512:
-  metadata.gz: a8e626ed0af7de549e6aa9a1904421bad0605613d11810554a0defe015730f6bc6e28e2563b92b6460a33fc9d4203d7041727e2007a76218b844a8fce4724709
-  data.tar.gz: 6b624235b3b53017a2721a37871e215e63fd38aa1d71591679e3976fe8fd26279f404cc37552908eaf52a3fb7b20ca4e872bed7f51c44a8dd10cd4cc41c0f806
+  metadata.gz: c491c3087d5341e5ab88bc607c2596be06fb90c482b74498b5aebd5a0eb5ef92f917b889b3ea26f56cb5a69be756bbc0afabfb957bff557cbbd7615f45b3934b
+  data.tar.gz: '090f85673e396225d96254c14fdfcdc941904354d3c11700be60b93e83e7c2e230bcbc15c8436ba2e0491223c77e0498f33d866beddb1e34379b7e4863916d1b'

data/CHANGELOG.md

@@ -7,6 +7,18 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Changed
 
+## [0.1.8] - 2026-01-22
+
+- **Fix**: Lograge custom options now appear in request logs
+- **Fix**: Request logs include request metadata fields (request_id, source_ip, user_agent, referer, host, content_type, accept)
+- **Docs**: Documented Lograge custom options and request metadata fields
+
+## [0.1.7] - 2025-12-06
+
+- **Fix**: Puma server detection now uses `$PROGRAM_NAME` instead of checking `defined?(::Puma::Server)` which was unreliable
+- **Fix**: Test isolation for `server_mode` state in configuration tests
+- **CI**: Updated to Ruby 3.4.7 and Rails 8.1.1
+
 ## [0.1.6] - 2025-11-30
 
 - Rename `PROVIDER_PUSH_TOKEN` secret to `TF_PROVIDER_GITHUB_TOKEN`

data/README.md

@@ -52,6 +52,7 @@ Once initialized (and enabled), the gem automatically includes its modules into
 - `ActiveSupport::TaggedLogging` is patched to support both Hashes and Strings (only when LogStruct is enabled)
 - `ActionMailer::Base` includes error handling and event logging modules
 - We configure `Lograge` for request logging
+- Lograge request logs include request metadata (request_id, source_ip, user_agent, referer, host, content_type, accept) and custom fields from `lograge_custom_options`
 - A Rack middleware is inserted to catch and log errors, including security violations (IP spoofing, CSRF, blocked hosts, etc.)
 - Structured logging is set up for ActiveJob, Sidekiq, Shrine, etc.
 - Rails `config.filter_parameters` are merged into LogStruct's filters and then cleared (to avoid double filtering). Configure sensitive keys via `LogStruct.config.filters`.

data/lib/log_struct/concerns/configuration.rb

@@ -10,7 +10,6 @@ module LogStruct
       module ClassMethods
         extend T::Sig
 
-        SERVER_COMMAND_ARGS = T.let(["server", "s"].freeze, T::Array[String])
         CONSOLE_COMMAND_ARGS = T.let(["console", "c"].freeze, T::Array[String])
         EMPTY_ARGV = T.let([].freeze, T::Array[String])
         CI_FALSE_VALUES = T.let(["false", "0", "no"].freeze, T::Array[String])
@@ -133,8 +132,30 @@ module LogStruct
         sig { returns(T::Boolean) }
         def server_process?
           return true if logstruct_server_mode?
+          return true if puma_server?
+          return true if defined?(::Unicorn::HttpServer)
+          return true if defined?(::Thin::Server)
+          return true if defined?(::Falcon::Server)
+          return true if defined?(::Rails::Server)
+          return true if sidekiq_server?
+
+          false
+        end
 
-          current_argv.any? { |arg| SERVER_COMMAND_ARGS.include?(arg) }
+        sig { returns(T::Boolean) }
+        def puma_server?
+          # Just checking defined?(::Puma::Server) is not reliable - Puma might be installed
+          # but not running. Check $PROGRAM_NAME and ARGV to verify we're actually running puma.
+          # ARGV check is needed when running through wrapper scripts like gosu.
+          return true if $PROGRAM_NAME.include?("puma")
+          return true if current_argv.any? { |arg| arg.include?("puma") }
+
+          false
+        end
+
+        sig { returns(T::Boolean) }
+        def sidekiq_server?
+          !!(defined?(::Sidekiq) && ::Sidekiq.respond_to?(:server?) && ::Sidekiq.server?)
         end
 
         sig { returns(T::Boolean) }

data/lib/log_struct/enums/log_field.rb

@@ -33,6 +33,9 @@ module LogStruct
       UserAgent = new(:user_agent)
       Referer = new(:referer)
       RequestId = new(:request_id)
+      Host = new(:host)
+      ContentType = new(:content_type)
+      Accept = new(:accept)
 
       # HTTP-specific fields
       Format = new(:format)

data/lib/log_struct/integrations/lograge.rb

@@ -13,6 +13,29 @@ module LogStruct
     module Lograge
       extend IntegrationInterface
 
+      LOGRAGE_KNOWN_KEYS = T.let(
+        [
+          :method,
+          :path,
+          :format,
+          :controller,
+          :action,
+          :status,
+          :duration,
+          :view,
+          :db,
+          :params,
+          :request_id,
+          :source_ip,
+          :user_agent,
+          :referer,
+          :host,
+          :content_type,
+          :accept
+        ].freeze,
+        T::Array[Symbol]
+      )
+
       class << self
         extend T::Sig
 
@@ -38,30 +61,9 @@ module LogStruct
             # The struct is converted to JSON by our Formatter (after filtering, etc.)
             config.lograge.formatter = T.let(
               lambda do |data|
-                # Coerce common fields to expected types
-                status = ((s = data[:status]) && s.respond_to?(:to_i)) ? s.to_i : s
-                duration_ms = ((d = data[:duration]) && d.respond_to?(:to_f)) ? d.to_f : d
-                view = ((v = data[:view]) && v.respond_to?(:to_f)) ? v.to_f : v
-                db = ((b = data[:db]) && b.respond_to?(:to_f)) ? b.to_f : b
-
-                params = data[:params]
-                params = params.deep_symbolize_keys if params&.respond_to?(:deep_symbolize_keys)
-
-                Log::Request.new(
-                  http_method: data[:method]&.to_s,
-                  path: data[:path]&.to_s,
-                  format: data[:format]&.to_sym,
-                  controller: data[:controller]&.to_s,
-                  action: data[:action]&.to_s,
-                  status: status,
-                  duration_ms: duration_ms,
-                  view: view,
-                  database: db,
-                  params: params,
-                  timestamp: Time.now
-                )
+                LogStruct::Integrations::Lograge.build_request_log(data)
               end,
-              T.proc.params(hash: T::Hash[Symbol, T.untyped]).returns(Log::Request)
+              T.proc.params(hash: T::Hash[T.any(Symbol, String), T.untyped]).returns(Log::Request)
             )
 
             # Add custom options to lograge
@@ -100,6 +102,7 @@ module LogStruct
           return if headers.blank?
 
           options[:user_agent] = headers["HTTP_USER_AGENT"]
+          options[:referer] = headers["HTTP_REFERER"]
           options[:content_type] = headers["CONTENT_TYPE"]
           options[:accept] = headers["HTTP_ACCEPT"]
         end
@@ -114,6 +117,66 @@ module LogStruct
           # The proc can modify the options hash directly
           custom_options_proc.call(event, options)
         end
+
+        sig { params(data: T::Hash[T.any(Symbol, String), T.untyped]).returns(Log::Request) }
+        def build_request_log(data)
+          normalized_data = normalize_lograge_data(data)
+
+          # Coerce common fields to expected types
+          status = ((s = normalized_data[:status]) && s.respond_to?(:to_i)) ? s.to_i : s
+          duration_ms = ((d = normalized_data[:duration]) && d.respond_to?(:to_f)) ? d.to_f : d
+          view = ((v = normalized_data[:view]) && v.respond_to?(:to_f)) ? v.to_f : v
+          db = ((b = normalized_data[:db]) && b.respond_to?(:to_f)) ? b.to_f : b
+
+          params = normalized_data[:params]
+          params = params.deep_symbolize_keys if params&.respond_to?(:deep_symbolize_keys)
+
+          additional_data = extract_additional_data(normalized_data)
+
+          Log::Request.new(
+            http_method: normalized_data[:method]&.to_s,
+            path: normalized_data[:path]&.to_s,
+            format: normalized_data[:format]&.to_sym,
+            controller: normalized_data[:controller]&.to_s,
+            action: normalized_data[:action]&.to_s,
+            status: status,
+            duration_ms: duration_ms,
+            view: view,
+            database: db,
+            params: params,
+            request_id: normalized_data[:request_id]&.to_s,
+            source_ip: normalized_data[:source_ip]&.to_s,
+            user_agent: normalized_data[:user_agent]&.to_s,
+            referer: normalized_data[:referer]&.to_s,
+            host: normalized_data[:host]&.to_s,
+            content_type: normalized_data[:content_type]&.to_s,
+            accept: normalized_data[:accept]&.to_s,
+            additional_data: additional_data,
+            timestamp: Time.now
+          )
+        end
+
+        sig { params(data: T::Hash[T.any(Symbol, String), T.untyped]).returns(T::Hash[Symbol, T.untyped]) }
+        def normalize_lograge_data(data)
+          data.each_with_object({}) do |(key, value), normalized|
+            normalized[key.to_s.to_sym] = value
+          end
+        end
+
+        sig { params(data: T::Hash[Symbol, T.untyped]).returns(T.nilable(T::Hash[Symbol, T.untyped])) }
+        def extract_additional_data(data)
+          extras = T.let({}, T::Hash[Symbol, T.untyped])
+          data.each do |key, value|
+            next if LOGRAGE_KNOWN_KEYS.include?(key)
+            next if value.nil?
+
+            extras[key] = value
+          end
+
+          return nil if extras.empty?
+
+          extras
+        end
       end
     end
   end

data/lib/log_struct/integrations/shrine.rb

@@ -14,6 +14,8 @@ module LogStruct
       extend T::Sig
       extend IntegrationInterface
 
+      SHRINE_EVENTS = T.let(%i[upload exists download delete metadata open].freeze, T::Array[Symbol])
+
       # Set up Shrine structured logging
       sig { override.params(config: LogStruct::Configuration).returns(T.nilable(T::Boolean)) }
       def self.setup(config)
@@ -30,9 +32,10 @@ module LogStruct
           event_type = case event.name
           when :upload then Event::Upload
           when :download then Event::Download
+          when :open then Event::Download
           when :delete then Event::Delete
           when :metadata then Event::Metadata
-          when :exists then Event::Exist # ActiveStorage uses 'exist', may as well use that
+          when :exists then Event::Exist
           else Event::Unknown
           end
 
@@ -80,18 +83,78 @@ module LogStruct
             Log::Shrine::Metadata.new(**unknown_params)
           end
 
-          # Pass the structured hash to the logger
-          # If Rails.logger has our Formatter, it will handle JSON conversion
-          ::Shrine.logger.info log_data
+          # Log directly through SemanticLogger, NOT through Shrine.logger
+          # Shrine.logger is a basic Logger that would just call .to_s on the struct
+          ::SemanticLogger[::Shrine].info(log_data)
         end)
 
-        # Configure Shrine to use our structured log subscriber
-        ::Shrine.plugin :instrumentation,
-          events: %i[upload exists download delete],
-          log_subscriber: shrine_log_subscriber
+        # Check if instrumentation plugin is already loaded
+        # If so, we need to replace the existing subscribers, not add duplicates
+        if instrumentation_already_configured?
+          replace_existing_subscribers(shrine_log_subscriber)
+        else
+          # First time setup - configure the instrumentation plugin
+          ::Shrine.plugin :instrumentation,
+            events: SHRINE_EVENTS,
+            log_subscriber: shrine_log_subscriber
+        end
 
         true
       end
+
+      sig { returns(T::Boolean) }
+      def self.instrumentation_already_configured?
+        return false unless defined?(::Shrine)
+
+        opts = T.unsafe(::Shrine).opts
+        return false unless opts.is_a?(Hash)
+
+        instrumentation_opts = opts[:instrumentation]
+        return false unless instrumentation_opts.is_a?(Hash)
+
+        subscribers = instrumentation_opts[:subscribers]
+        return false unless subscribers.is_a?(Hash)
+
+        !subscribers.empty?
+      end
+
+      sig { params(new_subscriber: T.untyped).void }
+      def self.replace_existing_subscribers(new_subscriber)
+        opts = T.unsafe(::Shrine).opts
+        instrumentation_opts = opts[:instrumentation]
+        subscribers = instrumentation_opts[:subscribers]
+
+        # Clear all existing subscribers and add our new one
+        SHRINE_EVENTS.each do |event_name|
+          # Clear existing subscribers for this event
+          subscribers[event_name] = [] if subscribers[event_name]
+
+          # Add our subscriber
+          subscribers[event_name] ||= []
+          subscribers[event_name] << new_subscriber
+
+          # Also re-subscribe via ActiveSupport::Notifications
+          # Shrine uses "shrine.#{event_name}" as the notification name
+          notification_name = "shrine.#{event_name}"
+
+          # Unsubscribe existing listeners for this event
+          # ActiveSupport::Notifications stores subscriptions, we need to find and remove them
+          notifier = ::ActiveSupport::Notifications.notifier
+          if notifier.respond_to?(:listeners_for)
+            # Rails 7.0+ uses listeners_for
+            listeners = notifier.listeners_for(notification_name)
+            listeners.each do |listener|
+              ::ActiveSupport::Notifications.unsubscribe(listener)
+            end
+          end
+
+          # Subscribe our new subscriber
+          ::ActiveSupport::Notifications.subscribe(notification_name) do |*args|
+            event = ::ActiveSupport::Notifications::Event.new(*args)
+            new_subscriber.call(event)
+          end
+        end
+      end
     end
   end
 end

data/lib/log_struct/log/request.rb

@@ -44,6 +44,14 @@ module LogStruct
       const :view, T.nilable(Float), default: nil
       const :database, T.nilable(Float), default: nil
       const :params, T.nilable(T::Hash[Symbol, T.untyped]), default: nil
+      const :host, T.nilable(String), default: nil
+      const :content_type, T.nilable(String), default: nil
+      const :accept, T.nilable(String), 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)
       include LogStruct::Log::Interfaces::RequestFields
@@ -70,6 +78,9 @@ module LogStruct
         h[LogField::View] = view unless view.nil?
         h[LogField::Database] = database unless database.nil?
         h[LogField::Params] = params unless params.nil?
+        h[LogField::Host] = host unless host.nil?
+        h[LogField::ContentType] = content_type unless content_type.nil?
+        h[LogField::Accept] = accept unless accept.nil?
         h
       end
     end

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

@@ -3,16 +3,19 @@
 
 require "active_support/tagged_logging"
 
-# Monkey-patch ActiveSupport::TaggedLogging::Formatter to support hash inputs
-# This allows us to pass structured data to the logger and have tags incorporated
-# directly into the hash instead of being prepended as strings
+# Monkey-patch ActiveSupport::TaggedLogging::Formatter to work with structured logging.
+#
+# Problem: Rails' TaggedLogging prepends tags as text and converts messages to strings.
+# When we pass a hash to super(), Rails does "#{tags_text}#{msg}" which calls .to_s
+# on the hash, producing Ruby inspect format {message: "..."} instead of valid JSON.
+#
+# Solution: When LogStruct is enabled, we add tags as a hash entry and delegate to
+# LogStruct::Formatter for proper JSON serialization with filtering and standard fields.
 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] || []
@@ -23,29 +26,33 @@ module ActiveSupport
       extend T::Helpers
       requires_ancestor { ::ActiveSupport::TaggedLogging::Formatter }
 
-      # Override the call method to support hash input/output, and wrap
-      # plain strings in a Hash under a `msg` key.
-      # The data is then passed to our custom log formatter that transforms it
-      # into a JSON string before logging.
-      #
-      # IMPORTANT: This only applies when LogStruct is enabled. When disabled,
-      # we preserve the original Rails logging behavior to avoid wrapping
-      # messages in hashes (which would break default Rails log formatting).
       sig { params(severity: T.any(String, Symbol), time: Time, progname: T.untyped, data: T.untyped).returns(String) }
       def call(severity, time, progname, data)
-        # Skip hash wrapping when LogStruct is disabled to preserve default Rails behavior
+        # Preserve original Rails behavior when LogStruct is disabled
         return super unless ::LogStruct.enabled?
 
-        # Convert data to a hash if it's not already one
-        data = {message: data.to_s} unless data.is_a?(Hash)
-
-        # Add current tags to the hash if present
-        # Use thread-local storage directly as fallback if current_tags method doesn't exist
+        # Get current tags
         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
-        super
+        # Add tags to data as hash entry (not text prefix)
+        data_with_tags = if data.is_a?(Hash)
+          tags.present? ? data.merge(tags: tags) : data
+        elsif data.is_a?(::LogStruct::Log::Interfaces::CommonFields) || (data.is_a?(T::Struct) && data.respond_to?(:serialize))
+          hash = T.unsafe(data).serialize
+          tags.present? ? hash.merge(tags: tags) : hash
+        else
+          tags.present? ? {message: data.to_s, tags: tags} : {message: data.to_s}
+        end
+
+        # Delegate to LogStruct::Formatter for JSON serialization with filtering
+        logstruct_formatter.call(severity, time, progname, data_with_tags)
+      end
+
+      private
+
+      sig { returns(::LogStruct::Formatter) }
+      def logstruct_formatter
+        @logstruct_formatter ||= T.let(::LogStruct::Formatter.new, T.nilable(::LogStruct::Formatter))
       end
     end
   end

data/lib/log_struct/semantic_logger/formatter.rb

@@ -61,16 +61,12 @@ 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
-        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)
-          # Direct LogStruct (fallback case)
-          @logstruct_formatter.call(log.level, log.time, log.name, log.payload)
-        elsif log.payload.is_a?(Hash) && log.payload[:payload].is_a?(T::Struct)
-          # T::Struct wrapped in payload hash
-          @logstruct_formatter.call(log.level, log.time, log.name, log.payload[:payload])
+        # Extract LogStruct from various locations where it might be stored
+        logstruct = extract_logstruct(log)
+
+        json = if logstruct
+          # Use our formatter to process LogStruct types directly
+          @logstruct_formatter.call(log.level, log.time, log.name, logstruct)
         elsif log.payload.is_a?(Hash) || log.payload.is_a?(T::Struct)
           # Process hashes and T::Structs through our formatter
           @logstruct_formatter.call(log.level, log.time, log.name, log.payload)
@@ -89,6 +85,48 @@ module LogStruct
 
       private
 
+      # Extract a LogStruct from the various places it might be stored in a SemanticLogger::Log
+      sig do
+        params(log: ::SemanticLogger::Log).returns(
+          T.nilable(
+            T.any(
+              LogStruct::Log::Interfaces::CommonFields,
+              LogStruct::Log::Interfaces::PublicCommonFields,
+              T::Struct
+            )
+          )
+        )
+      end
+      def extract_logstruct(log)
+        # Check payload first (most common path for structured logging)
+        if log.payload.is_a?(Hash) && log.payload[:payload].is_a?(LogStruct::Log::Interfaces::CommonFields)
+          return T.cast(log.payload[:payload], LogStruct::Log::Interfaces::CommonFields)
+        end
+
+        if log.payload.is_a?(LogStruct::Log::Interfaces::CommonFields)
+          return log.payload
+        end
+
+        if log.payload.is_a?(LogStruct::Log::Interfaces::PublicCommonFields)
+          return log.payload
+        end
+
+        # Check message - this is where structs end up when passed directly to logger.info(struct)
+        if log.message.is_a?(LogStruct::Log::Interfaces::CommonFields)
+          return T.cast(log.message, LogStruct::Log::Interfaces::CommonFields)
+        end
+
+        # Check for T::Struct in payload hash (might be a LogStruct struct not implementing CommonFields directly)
+        if log.payload.is_a?(Hash) && log.payload[:payload].is_a?(T::Struct)
+          struct = log.payload[:payload]
+          if struct.respond_to?(:source) && struct.respond_to?(:event)
+            return struct
+          end
+        end
+
+        nil
+      end
+
       sig { returns(LogStruct::Formatter) }
       attr_reader :logstruct_formatter
     end

data/lib/log_struct/semantic_logger/setup.rb

@@ -101,7 +101,7 @@ module LogStruct
 
       sig { params(app: T.untyped).returns(Symbol) }
       def self.determine_log_level(app)
-        if app.config.log_level
+        level = if app.config.log_level
           app.config.log_level
         elsif Rails.env.production?
           :info
@@ -110,6 +110,8 @@ module LogStruct
         else
           :debug
         end
+        # Rails config.log_level can be a String or Symbol
+        level.is_a?(String) ? level.to_sym : level
       end
 
       sig { params(app: T.untyped).void }

data/lib/log_struct/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: logstruct
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.8
 platform: ruby
 authors:
 - DocSpring