logstruct 0.1.9 → 0.1.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 95828f14e3935518654b94939f2cee577f296d454fa3666a8e5f1eb9ababb1dd
-  data.tar.gz: dcd8ff40d991a79573fe60e678ea85590b9597f1e0163f132f8eff79015a88ff
+  metadata.gz: 90d690080da4286690ca86f0d9eb5b9514483f2324898f07912d66015ec4269d
+  data.tar.gz: df38c5f2434cc5afae25606f77ab2d9a532c9d77c58f81bd558824907ed66418
 SHA512:
-  metadata.gz: 868f9dc4e320fbdf752b0e3b901280b5a972b9759592869587bf3673d905ddb3b554851c0dfe977eafe543be37b37105f9f759cccc8d06a009771585c931ce58
-  data.tar.gz: b8402c46a941a578261933249acddff294551d5fd5b1823ed54e48ce2f17ba1e760919a540ef38918706004093a1b3c0f5a89e16405037e4e86cbd6a114bc363
+  metadata.gz: f654b8b6b7ecf8114c08d4c2b3f9d0f97160bfbd44f60b89ffb08001fed4b186bf7c9697ea8ca1b9ac2d25071f481637e4b050ab4be01efac286d793c12cb7ff
+  data.tar.gz: 88f8fcf0c87b5e2ccd96152d8abb3de94aaeb952879a37c4cb4fdb84fa9fa858d7fb230f50a8e4d440e30e3a6746cb6bb7b0dc3abdd1dc5f7d95ddfbfed18f0b

data/CHANGELOG.md

@@ -9,6 +9,24 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Changed
 
+## [0.1.11] - 2026-01-28
+
+### Changed
+
+- **Dev**: Added jscpd task/config and refactored repeated helpers in tests and codegen
+
+### Fixed
+
+- **Fix**: Restore request logs in Puma cluster mode by reopening SemanticLogger in forked workers
+- **Fix**: Normalize ActiveJob and GoodJob timestamps to real wall clock time
+- **Fix**: Tagged logging now emits `msg` instead of `message` for AMS-style logs
+
+## [0.1.10] - 2026-01-23
+
+### Added
+
+- **Feature**: `request_id` now appears on all logs during a request, not just the request log
+
 ## [0.1.9] - 2026-01-23
 
 ### Changed

data/lib/log_struct/enums/log_field.rb

@@ -32,7 +32,7 @@ module LogStruct
       SourceIp = new(:source_ip)
       UserAgent = new(:user_agent)
       Referer = new(:referer)
-      RequestId = new(:request_id)
+      RequestId = new(:req_id)
       Host = new(:host)
       ContentType = new(:content_type)
       Accept = new(:accept)

data/lib/log_struct/formatter.rb

@@ -190,6 +190,10 @@ module LogStruct
       data[:ts] ||= time.iso8601(3)
       data[:lvl] = level_enum # Set level from severity parameter
       data[:prog] = progname if progname.present?
+      request_id = Thread.current[:logstruct_request_id]
+      if request_id.is_a?(String) && !request_id.empty? && !data.key?(:req_id)
+        data[:req_id] = request_id
+      end
 
       generate_json(data)
     end

data/lib/log_struct/integrations/action_mailer/error_handling.rb

@@ -150,38 +150,8 @@ module LogStruct
 
           # Report to error reporting service if requested
           if report
-            # Get message if available
-            mailer_message = respond_to?(:message) ? message : nil
-
-            # Prepare universal mailer fields
-            message_data = {}
-            MetadataCollection.add_message_metadata(self, message_data)
-
-            # Prepare app-specific context data
             context_data = {recipients: recipients(error)}
-            MetadataCollection.add_context_metadata(self, context_data)
-
-            # Extract email fields
-            to = mailer_message&.to
-            from = mailer_message&.from&.first
-            subject = mailer_message&.subject
-            message_id = extract_message_id_from_mailer(self)
-
-            # Create ActionMailer-specific error struct
-            exception_data = Log::ActionMailer::Error.new(
-              to: to,
-              from: from,
-              subject: subject,
-              message_id: message_id,
-              mailer_class: self.class.to_s,
-              mailer_action: respond_to?(:action_name) ? action_name&.to_s : nil,
-              attachment_count: message_data[:attachment_count],
-              error_class: error.class,
-              message: error.message,
-              backtrace: error.backtrace,
-              additional_data: context_data.presence,
-              timestamp: Time.now
-            )
+            exception_data = build_exception_data(error, Level::Error, context_data)
 
             # Log the exception with structured data
             LogStruct.error(exception_data)
@@ -202,29 +172,32 @@ module LogStruct
         # Log a notification event that can be picked up by external systems
         sig { params(error: StandardError).void }
         def log_notification_event(error)
-          # Get message if available
-          mailer_message = respond_to?(:message) ? message : nil
-
-          # Prepare universal mailer fields
-          message_data = {}
-          MetadataCollection.add_message_metadata(self, message_data)
-
-          # Prepare app-specific context data
           context_data = {
             mailer: self.class.to_s,
             action: action_name&.to_s,
             recipients: recipients(error)
           }
+          exception_data = build_exception_data(error, Level::Info, context_data)
+
+          # Log the error at info level since it's not a critical error
+          LogStruct.info(exception_data)
+        end
+
+        sig { params(error: StandardError, level: Level, context_data: T::Hash[Symbol, T.untyped]).returns(Log::ActionMailer::Error) }
+        def build_exception_data(error, level, context_data)
+          mailer_message = respond_to?(:message) ? message : nil
+
+          message_data = {}
+          MetadataCollection.add_message_metadata(self, message_data)
+
           MetadataCollection.add_context_metadata(self, context_data)
 
-          # Extract email fields
           to = mailer_message&.to
           from = mailer_message&.from&.first
           subject = mailer_message&.subject
           message_id = extract_message_id_from_mailer(self)
 
-          # Create ActionMailer-specific error struct
-          exception_data = Log::ActionMailer::Error.new(
+          Log::ActionMailer::Error.new(
             to: to,
             from: from,
             subject: subject,
@@ -237,11 +210,8 @@ module LogStruct
             backtrace: error.backtrace,
             additional_data: context_data.presence,
             timestamp: Time.now,
-            level: Level::Info
+            level: level
           )
-
-          # Log the error at info level since it's not a critical error
-          LogStruct.info(exception_data)
         end
 
         sig { params(error: StandardError).returns(String) }

data/lib/log_struct/integrations/action_mailer/metadata_collection.rb

@@ -54,12 +54,6 @@ module LogStruct
           end
           log_data[:tags] = tags if tags.present?
 
-          # Get request_id from ActionDispatch if available
-          if ::ActionDispatch::Request.respond_to?(:current_request_id) &&
-              T.unsafe(::ActionDispatch::Request).current_request_id.present?
-            log_data[:request_id] = T.unsafe(::ActionDispatch::Request).current_request_id
-          end
-
           # Get job_id from ActiveJob if available
           if defined?(::ActiveJob::Logging) && ::ActiveJob::Logging.respond_to?(:job_id) &&
               T.unsafe(::ActiveJob::Logging).job_id.present?

data/lib/log_struct/integrations/active_job/log_subscriber.rb

@@ -6,6 +6,7 @@ require_relative "../../enums/source"
 require_relative "../../enums/event"
 require_relative "../../log/active_job"
 require_relative "../../log/error"
+require_relative "../event_time"
 
 module LogStruct
   module Integrations
@@ -17,7 +18,7 @@ module LogStruct
         sig { params(event: ::ActiveSupport::Notifications::Event).void }
         def enqueue(event)
           job = T.cast(event.payload[:job], ::ActiveJob::Base)
-          ts = event.time ? Time.at(event.time) : Time.now
+          ts = EventTime.coerce_event_time(event.time)
           base_fields = build_base_fields(job)
           logger.info(Log::ActiveJob::Enqueue.new(
             **base_fields.to_kwargs,
@@ -28,7 +29,7 @@ module LogStruct
         sig { params(event: ::ActiveSupport::Notifications::Event).void }
         def enqueue_at(event)
           job = T.cast(event.payload[:job], ::ActiveJob::Base)
-          ts = event.time ? Time.at(event.time) : Time.now
+          ts = EventTime.coerce_event_time(event.time)
           base_fields = build_base_fields(job)
           logger.info(Log::ActiveJob::Schedule.new(
             **base_fields.to_kwargs,
@@ -46,10 +47,8 @@ module LogStruct
             # Log the exception with the job context
             log_exception(exception, job, event)
           else
-            start_float = event.time
-            end_float = event.end
-            ts = start_float ? Time.at(start_float) : Time.now
-            finished_at = end_float ? Time.at(end_float) : Time.now
+            ts = EventTime.coerce_event_time(event.time)
+            finished_at = EventTime.coerce_event_time(event.end)
             base_fields = build_base_fields(job)
             logger.info(Log::ActiveJob::Finish.new(
               **base_fields.to_kwargs,
@@ -63,7 +62,7 @@ module LogStruct
         sig { params(event: ::ActiveSupport::Notifications::Event).void }
         def perform_start(event)
           job = T.cast(event.payload[:job], ::ActiveJob::Base)
-          ts = event.time ? Time.at(event.time) : Time.now
+          ts = EventTime.coerce_event_time(event.time)
           started_at = ts
           attempt = job.executions
           base_fields = build_base_fields(job)

data/lib/log_struct/integrations/dotenv.rb

@@ -34,6 +34,20 @@ module LogStruct
       class << self
         extend T::Sig
 
+        sig { params(env: T.untyped).returns(String) }
+        def relative_env_path(env)
+          abs = env.filename
+          begin
+            if defined?(::Rails) && ::Rails.respond_to?(:root) && ::Rails.root
+              Pathname.new(abs).relative_path_from(Pathname.new(::Rails.root.to_s)).to_s
+            else
+              abs
+            end
+          rescue
+            abs
+          end
+        end
+
         sig { void }
         def subscribe!
           # Guard against double subscription
@@ -47,16 +61,7 @@ module LogStruct
             LogStruct::Log::Dotenv.new
             event = ::ActiveSupport::Notifications::Event.new(*args)
             env = event.payload[:env]
-            abs = env.filename
-            file = begin
-              if defined?(::Rails) && ::Rails.respond_to?(:root) && ::Rails.root
-                Pathname.new(abs).relative_path_from(Pathname.new(::Rails.root.to_s)).to_s
-              else
-                abs
-              end
-            rescue
-              abs
-            end
+            file = relative_env_path(env)
 
             ts = event.time ? Time.at(event.time) : Time.now
             LogStruct.info(Log::Dotenv::Load.new(file: file, timestamp: ts))
@@ -134,16 +139,7 @@ module LogStruct
         instrumenter.subscribe("load.dotenv") do |*args|
           event = ::ActiveSupport::Notifications::Event.new(*args)
           env = event.payload[:env]
-          abs = env.filename
-          file = begin
-            if defined?(::Rails) && ::Rails.respond_to?(:root) && ::Rails.root
-              Pathname.new(abs).relative_path_from(Pathname.new(::Rails.root.to_s)).to_s
-            else
-              abs
-            end
-          rescue
-            abs
-          end
+          file = relative_env_path(env)
           ts = event.time ? Time.at(event.time) : Time.now
           LogStruct::BootBuffer.add(Log::Dotenv::Load.new(file: file, timestamp: ts))
         rescue => e

data/lib/log_struct/integrations/event_time.rb

@@ -0,0 +1,19 @@
+# typed: strict
+# frozen_string_literal: true
+
+module LogStruct
+  module Integrations
+    module EventTime
+      extend T::Sig
+
+      sig { params(value: T.untyped).returns(Time) }
+      def self.coerce_event_time(value)
+        return value if value.is_a?(Time)
+        return Time.now unless value.is_a?(Numeric)
+
+        monotonic_now = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+        Time.now - (monotonic_now - value)
+      end
+    end
+  end
+end

data/lib/log_struct/integrations/good_job/log_subscriber.rb

@@ -10,6 +10,7 @@ end
 require_relative "../../log/good_job"
 require_relative "../../enums/event"
 require_relative "../../enums/level"
+require_relative "../event_time"
 
 module LogStruct
   module Integrations
@@ -43,7 +44,7 @@ module LogStruct
           payload = T.let(event.payload, T::Hash[Symbol, T.untyped])
           job = payload[:job]
           base_fields = build_base_fields(job, payload)
-          ts = event.time ? Time.at(event.time) : Time.now
+          ts = EventTime.coerce_event_time(event.time)
 
           logger.info(Log::GoodJob::Enqueue.new(
             **base_fields.to_kwargs,
@@ -61,7 +62,7 @@ module LogStruct
           job = payload[:job]
           execution = payload[:execution] || payload[:good_job_execution]
           base_fields = build_base_fields(job, payload)
-          ts = event.time ? Time.at(event.time) : Time.now
+          ts = EventTime.coerce_event_time(event.time)
 
           logger.info(Log::GoodJob::Start.new(
             **base_fields.to_kwargs,
@@ -82,8 +83,8 @@ module LogStruct
           payload = T.let(event.payload, T::Hash[Symbol, T.untyped])
           job = payload[:job]
           base_fields = build_base_fields(job, payload)
-          start_ts = event.time ? Time.at(event.time) : Time.now
-          end_ts = event.end ? Time.at(event.end) : Time.now
+          start_ts = EventTime.coerce_event_time(event.time)
+          end_ts = EventTime.coerce_event_time(event.end)
 
           logger.info(Log::GoodJob::Finish.new(
             **base_fields.to_kwargs,
@@ -103,7 +104,7 @@ module LogStruct
           job = payload[:job]
           execution = payload[:execution] || payload[:good_job_execution]
           exception = payload[:exception] || payload[:error]
-          ts = event.time ? Time.at(event.time) : Time.now
+          ts = EventTime.coerce_event_time(event.time)
           base_fields = build_base_fields(job, payload)
 
           logger.error(Log::GoodJob::Error.new(
@@ -125,7 +126,7 @@ module LogStruct
           payload = T.let(event.payload, T::Hash[Symbol, T.untyped])
           job = payload[:job]
           base_fields = build_base_fields(job, payload)
-          ts = event.time ? Time.at(event.time) : Time.now
+          ts = EventTime.coerce_event_time(event.time)
 
           logger.info(Log::GoodJob::Schedule.new(
             **base_fields.to_kwargs,

data/lib/log_struct/integrations/host_authorization.rb

@@ -63,7 +63,6 @@ module LogStruct
             source_ip: request.ip,
             user_agent: request.user_agent,
             referer: request.referer,
-            request_id: request.request_id,
             x_forwarded_for: request.x_forwarded_for,
             allowed_hosts: allowed_hosts_array&.empty? ? nil : allowed_hosts_array,
             allow_ip_hosts: allow_ip_hosts_value

data/lib/log_struct/integrations/lograge.rb

@@ -101,6 +101,12 @@ module LogStruct
           headers = event.payload[:headers]
           return if headers.blank?
 
+          # Rails' ActionDispatch::RequestId middleware stores request_id in headers
+          # Only set if not already present in payload (payload takes precedence)
+          if options[:request_id].blank? && headers["action_dispatch.request_id"].present?
+            options[:request_id] = headers["action_dispatch.request_id"]
+          end
+
           options[:user_agent] = headers["HTTP_USER_AGENT"]
           options[:referer] = headers["HTTP_REFERER"]
           options[:content_type] = headers["CONTENT_TYPE"]
@@ -144,7 +150,6 @@ module LogStruct
             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,

data/lib/log_struct/integrations/puma.rb

@@ -50,16 +50,7 @@ module LogStruct
           if ARGV.include?("server")
             # Emit deterministic boot/started events based on CLI args
             begin
-              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
+              port = port_from_argv(ARGV)
               si = T.cast(STATE[:start_info], T::Hash[Symbol, T.untyped])
               si[:pid] ||= Process.pid
               si[:environment] ||= ((defined?(::Rails) && ::Rails.respond_to?(:env)) ? ::Rails.env : nil)
@@ -116,6 +107,13 @@ module LogStruct
               ev = T.unsafe(::Object.const_get("Puma::Events"))
               ev.prepend(EventsPatch)
             end
+            if puma_mod&.const_defined?(:Cluster)
+              cluster_mod = T.cast(puma_mod.const_get(:Cluster), Module)
+              if cluster_mod.const_defined?(:Worker)
+                worker_class = T.cast(cluster_mod.const_get(:Worker), T::Class[T.anything])
+                worker_class.prepend(ClusterWorkerPatch)
+              end
+            end
             # Patch Rack::Handler::Puma.run to emit lifecycle logs using options
             if ::Object.const_defined?(:Rack)
               rack_mod = T.unsafe(::Object.const_get(:Rack))
@@ -168,6 +166,18 @@ module LogStruct
           }
         end
 
+        sig { params(argv: T::Array[String]).returns(T.nilable(String)) }
+        def port_from_argv(argv)
+          argv.each_with_index do |arg, idx|
+            if arg == "-p" || arg == "--port"
+              return argv[idx + 1]
+            elsif arg.start_with?("--port=")
+              return arg.split("=", 2)[1]
+            end
+          end
+          nil
+        end
+
         sig { params(line: String).returns(T::Boolean) }
         def process_line(line)
           l = line.to_s.strip
@@ -236,16 +246,7 @@ module LogStruct
             # Fallback: if no listening address captured yet, infer from ARGV
             if T.cast(si[:listening], T::Array[T.untyped]).empty?
               begin
-                port = T.let(nil, T.untyped)
-                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
+                port = port_from_argv(ARGV)
                 if port
                   si[:listening] << "tcp://127.0.0.1:#{port}"
                 end
@@ -389,6 +390,20 @@ module LogStruct
         end
       end
 
+      module ClusterWorkerPatch
+        extend T::Sig
+
+        sig { returns(T.untyped) }
+        def run
+          begin
+            ::SemanticLogger.reopen
+          rescue => e
+            ::LogStruct::Integrations::Puma.handle_integration_error(e)
+          end
+          super
+        end
+      end
+
       # Hook Rack::Handler::Puma.run to emit structured started/shutdown
       module RackHandlerPatch
         extend T::Sig

data/lib/log_struct/integrations/rack.rb

@@ -4,6 +4,7 @@
 require "rack"
 require "action_dispatch/middleware/show_exceptions"
 require_relative "rack/error_handling_middleware"
+require_relative "rack_setup"
 
 module LogStruct
   module Integrations
@@ -15,12 +16,11 @@ module LogStruct
       # Set up Rack middleware for structured error logging
       sig { override.params(config: LogStruct::Configuration).returns(T.nilable(T::Boolean)) }
       def self.setup(config)
-        return nil unless config.enabled
-        return nil unless config.integrations.enable_rack_error_handler
+        return nil unless RackSetup.enabled?(config)
 
         # Add structured logging middleware for security violations and errors
         # Need to insert after ShowExceptions to catch IP spoofing errors
-        ::Rails.application.middleware.insert_after(
+        RackSetup.insert_after(
           ::ActionDispatch::ShowExceptions,
           Integrations::RackErrorHandler::Middleware
         )

data/lib/log_struct/integrations/rack_error_handler/middleware.rb

@@ -71,7 +71,6 @@ module LogStruct
               http_method: env["REQUEST_METHOD"],
               user_agent: env["HTTP_USER_AGENT"],
               referer: env["HTTP_REFERER"],
-              request_id: request.request_id,
               message: ip_spoof_error.message,
               client_ip: env["HTTP_CLIENT_IP"],
               x_forwarded_for: env["HTTP_X_FORWARDED_FOR"],
@@ -90,7 +89,6 @@ module LogStruct
                 source_ip: request.remote_ip,
                 user_agent: request.user_agent,
                 referer: request.referer,
-                request_id: request.request_id,
                 message: error.message,
                 timestamp: Time.now
               )
@@ -137,7 +135,6 @@ module LogStruct
         def extract_request_context(env, request = nil)
           request ||= ::ActionDispatch::Request.new(env)
           {
-            request_id: request.request_id,
             path: request.path,
             method: request.method,
             user_agent: request.user_agent,

data/lib/log_struct/integrations/rack_error_handler.rb

@@ -4,6 +4,7 @@
 require "rack"
 require "action_dispatch/middleware/show_exceptions"
 require_relative "rack_error_handler/middleware"
+require_relative "rack_setup"
 
 module LogStruct
   module Integrations
@@ -15,12 +16,11 @@ module LogStruct
       # Set up Rack middleware for structured error logging
       sig { override.params(config: LogStruct::Configuration).returns(T.nilable(T::Boolean)) }
       def self.setup(config)
-        return nil unless config.enabled
-        return nil unless config.integrations.enable_rack_error_handler
+        return nil unless RackSetup.enabled?(config)
 
         # Add structured logging middleware for security violations and errors
         # Need to insert before RemoteIp to catch IP spoofing errors it raises
-        ::Rails.application.middleware.insert_before(
+        RackSetup.insert_before(
           ::ActionDispatch::RemoteIp,
           Integrations::RackErrorHandler::Middleware
         )

data/lib/log_struct/integrations/rack_setup.rb

@@ -0,0 +1,28 @@
+# typed: strict
+# frozen_string_literal: true
+
+module LogStruct
+  module Integrations
+    module RackSetup
+      extend T::Sig
+
+      sig { params(config: LogStruct::Configuration).returns(T::Boolean) }
+      def self.enabled?(config)
+        return false unless config.enabled
+        return false unless config.integrations.enable_rack_error_handler
+
+        true
+      end
+
+      sig { params(anchor: T.untyped, middleware: T.untyped).void }
+      def self.insert_after(anchor, middleware)
+        ::Rails.application.middleware.insert_after(anchor, middleware)
+      end
+
+      sig { params(anchor: T.untyped, middleware: T.untyped).void }
+      def self.insert_before(anchor, middleware)
+        ::Rails.application.middleware.insert_before(anchor, middleware)
+      end
+    end
+  end
+end

data/lib/log_struct/integrations/request_context/middleware.rb

@@ -0,0 +1,31 @@
+# typed: strict
+# frozen_string_literal: true
+
+module LogStruct
+  module Integrations
+    module RequestContext
+      # Middleware that captures request_id and stores it in SemanticLogger's
+      # named_tags so all logs during the request include the request_id.
+      class Middleware
+        extend T::Sig
+
+        sig { params(app: T.untyped).void }
+        def initialize(app)
+          @app = app
+        end
+
+        sig { params(env: T.untyped).returns(T.untyped) }
+        def call(env)
+          request = ::ActionDispatch::Request.new(env)
+          request_id = request.request_id
+          Thread.current[:logstruct_request_id] = request_id
+          ::SemanticLogger.push_named_tags(request_id: request_id)
+          @app.call(env)
+        ensure
+          ::SemanticLogger.pop_named_tags
+          Thread.current[:logstruct_request_id] = nil
+        end
+      end
+    end
+  end
+end

data/lib/log_struct/integrations/request_context.rb

@@ -0,0 +1,27 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative "request_context/middleware"
+
+module LogStruct
+  module Integrations
+    # Request context integration that captures request_id for all logs
+    module RequestContext
+      extend T::Sig
+      extend IntegrationInterface
+
+      sig { override.params(config: LogStruct::Configuration).returns(T.nilable(T::Boolean)) }
+      def self.setup(config)
+        return nil unless config.enabled
+
+        # Insert after RequestId middleware so request_id is available
+        ::Rails.application.middleware.insert_after(
+          ::ActionDispatch::RequestId,
+          Integrations::RequestContext::Middleware
+        )
+
+        true
+      end
+    end
+  end
+end

data/lib/log_struct/integrations.rb

@@ -2,6 +2,7 @@
 # frozen_string_literal: true
 
 require_relative "integrations/integration_interface"
+require_relative "integrations/request_context"
 require_relative "integrations/active_job"
 require_relative "integrations/active_record"
 require_relative "integrations/rack_error_handler"
@@ -77,6 +78,7 @@ module LogStruct
 
     sig { params(config: LogStruct::Configuration).void }
     def self.setup_middleware_integrations(config)
+      Integrations::RequestContext.setup(config)
       Integrations::HostAuthorization.setup(config) if config.integrations.enable_host_authorization
       Integrations::RackErrorHandler.setup(config) if config.integrations.enable_rack_error_handler
     end

data/lib/log_struct/log/request.rb

@@ -33,7 +33,6 @@ module LogStruct
       const :source_ip, T.nilable(String), default: nil
       const :user_agent, T.nilable(String), default: nil
       const :referer, T.nilable(String), default: nil
-      const :request_id, T.nilable(String), default: nil
 
       # Event-specific fields
       const :format, T.nilable(Symbol), default: nil
@@ -69,7 +68,6 @@ module LogStruct
         h[LogField::SourceIp] = source_ip unless source_ip.nil?
         h[LogField::UserAgent] = user_agent unless user_agent.nil?
         h[LogField::Referer] = referer unless referer.nil?
-        h[LogField::RequestId] = request_id unless request_id.nil?
         h[LogField::Format] = format unless format.nil?
         h[LogField::Controller] = controller unless controller.nil?
         h[LogField::Action] = action unless action.nil?

data/lib/log_struct/log/security/blocked_host.rb

@@ -34,7 +34,6 @@ module LogStruct
         const :source_ip, T.nilable(String), default: nil
         const :user_agent, T.nilable(String), default: nil
         const :referer, T.nilable(String), default: nil
-        const :request_id, T.nilable(String), default: nil
 
         # Event-specific fields
         const :message, T.nilable(String), default: nil
@@ -65,7 +64,6 @@ module LogStruct
           h[LogField::SourceIp] = source_ip unless source_ip.nil?
           h[LogField::UserAgent] = user_agent unless user_agent.nil?
           h[LogField::Referer] = referer unless referer.nil?
-          h[LogField::RequestId] = request_id unless request_id.nil?
           h[LogField::Message] = message unless message.nil?
           h[LogField::BlockedHost] = blocked_host unless blocked_host.nil?
           h[LogField::BlockedHosts] = blocked_hosts unless blocked_hosts.nil?

data/lib/log_struct/log/security/csrf_violation.rb

@@ -34,7 +34,6 @@ module LogStruct
         const :source_ip, T.nilable(String), default: nil
         const :user_agent, T.nilable(String), default: nil
         const :referer, T.nilable(String), default: nil
-        const :request_id, T.nilable(String), default: nil
 
         # Event-specific fields
         const :message, T.nilable(String), default: nil
@@ -60,7 +59,6 @@ module LogStruct
           h[LogField::SourceIp] = source_ip unless source_ip.nil?
           h[LogField::UserAgent] = user_agent unless user_agent.nil?
           h[LogField::Referer] = referer unless referer.nil?
-          h[LogField::RequestId] = request_id unless request_id.nil?
           h[LogField::Message] = message unless message.nil?
           h
         end

data/lib/log_struct/log/security/ip_spoof.rb

@@ -34,7 +34,6 @@ module LogStruct
         const :source_ip, T.nilable(String), default: nil
         const :user_agent, T.nilable(String), default: nil
         const :referer, T.nilable(String), default: nil
-        const :request_id, T.nilable(String), default: nil
 
         # Event-specific fields
         const :message, T.nilable(String), default: nil
@@ -62,7 +61,6 @@ module LogStruct
           h[LogField::SourceIp] = source_ip unless source_ip.nil?
           h[LogField::UserAgent] = user_agent unless user_agent.nil?
           h[LogField::Referer] = referer unless referer.nil?
-          h[LogField::RequestId] = request_id unless request_id.nil?
           h[LogField::Message] = message unless message.nil?
           h[LogField::ClientIp] = client_ip unless client_ip.nil?
           h[LogField::XForwardedFor] = x_forwarded_for unless x_forwarded_for.nil?

data/lib/log_struct/log/security.rb

@@ -20,7 +20,6 @@ module LogStruct
         const :source_ip, T.nilable(String), default: nil
         const :user_agent, T.nilable(String), default: nil
         const :referer, T.nilable(String), default: nil
-        const :request_id, T.nilable(String), default: nil
 
         Kwargs = T.type_alias do
           {
@@ -28,8 +27,7 @@ module LogStruct
             http_method: T.nilable(String),
             source_ip: T.nilable(String),
             user_agent: T.nilable(String),
-            referer: T.nilable(String),
-            request_id: T.nilable(String)
+            referer: T.nilable(String)
           }
         end
 
@@ -40,8 +38,7 @@ module LogStruct
             http_method: http_method,
             source_ip: source_ip,
             user_agent: user_agent,
-            referer: referer,
-            request_id: request_id
+            referer: referer
           }
         end
       end

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

@@ -41,7 +41,8 @@ module ActiveSupport
           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}
+          base = {LogStruct::LogField::Message.serialize => data.to_s}
+          tags.present? ? base.merge(tags: tags) : base
         end
 
         # Delegate to LogStruct::Formatter for JSON serialization with filtering

data/lib/log_struct/railtie.rb

@@ -46,16 +46,7 @@ module LogStruct
       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
+        port = LogStruct::Integrations::Puma.port_from_argv(ARGV)
         started = LogStruct::Log::Puma::Start.new(
           mode: "single",
           environment: (defined?(::Rails) && ::Rails.respond_to?(:env)) ? ::Rails.env : nil,

data/lib/log_struct/semantic_logger/color_formatter.rb

@@ -62,44 +62,11 @@ module LogStruct
       def call(log, logger)
         # Handle LogStruct types specially with colorization
         if log.payload.is_a?(LogStruct::Log::Interfaces::CommonFields)
-          # Get the LogStruct formatted JSON
-          logstruct_json = @logstruct_formatter.call(log.level, log.time, log.name, log.payload)
-
-          # Parse and colorize it
-          begin
-            parsed_data = T.let(JSON.parse(logstruct_json), T::Hash[String, T.untyped])
-            colorized_json = colorize_json(parsed_data)
-
-            # Use SemanticLogger's prefix formatting but with our colorized content
-            prefix = format("%<time>s %<level>s [%<process>s] %<name>s -- ",
-              time: format_time(log.time),
-              level: format_level(log.level),
-              process: log.process_info,
-              name: format_name(log.name))
-
-            "#{prefix}#{colorized_json}\n"
-          rescue JSON::ParserError
-            # Fallback to standard formatting
-            super
-          end
+          formatted = format_logstruct_payload(log)
+          formatted if formatted
         elsif log.payload.is_a?(Hash) || log.payload.is_a?(T::Struct)
-          # Process hashes through our formatter then colorize
-          begin
-            logstruct_json = @logstruct_formatter.call(log.level, log.time, log.name, log.payload)
-            parsed_data = T.let(JSON.parse(logstruct_json), T::Hash[String, T.untyped])
-            colorized_json = colorize_json(parsed_data)
-
-            prefix = format("%<time>s %<level>s [%<process>s] %<name>s -- ",
-              time: format_time(log.time),
-              level: format_level(log.level),
-              process: log.process_info,
-              name: format_name(log.name))
-
-            "#{prefix}#{colorized_json}\n"
-          rescue JSON::ParserError
-            # Fallback to standard formatting
-            super
-          end
+          formatted = format_logstruct_payload(log)
+          formatted if formatted
         else
           # For plain messages, use SemanticLogger's default colorization
           super
@@ -139,6 +106,24 @@ module LogStruct
           .gsub(": null", ": " + colorize_text("null", :nil))
       end
 
+      sig { params(log: ::SemanticLogger::Log).returns(T.nilable(String)) }
+      def format_logstruct_payload(log)
+        logstruct_json = @logstruct_formatter.call(log.level, log.time, log.name, log.payload)
+
+        parsed_data = T.let(JSON.parse(logstruct_json), T::Hash[String, T.untyped])
+        colorized_json = colorize_json(parsed_data)
+
+        prefix = format("%<time>s %<level>s [%<process>s] %<name>s -- ",
+          time: format_time(log.time),
+          level: format_level(log.level),
+          process: log.process_info,
+          name: format_name(log.name))
+
+        "#{prefix}#{colorized_json}\n"
+      rescue JSON::ParserError
+        nil
+      end
+
       # Add ANSI color codes to text
       sig { params(text: String, color_type: Symbol).returns(String) }
       def colorize_text(text, color_type)

data/lib/log_struct/semantic_logger/formatter.rb

@@ -79,6 +79,15 @@ module LogStruct
           )
           @logstruct_formatter.call(log.level, log.time, log.name, plain_log)
         end
+
+        # Add request_id from named_tags if present
+        request_id = log.named_tags[:request_id]
+        if request_id
+          data = JSON.parse(json)
+          data["req_id"] = request_id
+          json = data.to_json
+        end
+
         # SemanticLogger appenders typically add their own newline. Avoid double newlines by stripping ours.
         json.end_with?("\n") ? json.chomp : json
       end

data/lib/log_struct/semantic_logger/logger.rb

@@ -148,7 +148,9 @@ module LogStruct
     end
 
     # Proxy object to provide ActiveJob-compatible formatter interface
-    class FormatterProxy
+    # Also implements the standard Logger formatter interface (call method)
+    # for compatibility with Ruby's Logger (especially logger gem 1.7.0+)
+    class FormatterProxy < ::Logger::Formatter
       extend T::Sig
 
       sig { returns(T::Array[T.any(String, Symbol)]) }

data/lib/log_struct/shared/add_request_fields.rb

@@ -20,7 +20,6 @@ module LogStruct
           hash[LogField::SourceIp.serialize] = source_ip if source_ip
           hash[LogField::UserAgent.serialize] = user_agent if user_agent
           hash[LogField::Referer.serialize] = referer if referer
-          hash[LogField::RequestId.serialize] = request_id if request_id
         end
       end
     end

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

@@ -0,0 +1,29 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative "../../enums/level"
+
+module LogStruct
+  module Log
+    module Interfaces
+      module CommonFieldBase
+        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

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

@@ -4,6 +4,7 @@
 require_relative "../../enums/source"
 require_relative "../../enums/event"
 require_relative "../../enums/level"
+require_relative "common_field_base"
 
 module LogStruct
   module Log
@@ -14,6 +15,8 @@ module LogStruct
 
         interface!
 
+        include CommonFieldBase
+
         sig { abstract.returns(Source) }
         def source
         end
@@ -21,18 +24,6 @@ module LogStruct
         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

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

@@ -2,6 +2,7 @@
 # frozen_string_literal: true
 
 require_relative "../../enums/level"
+require_relative "common_field_base"
 
 module LogStruct
   module Log
@@ -12,17 +13,7 @@ module LogStruct
 
         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
+        include CommonFieldBase
       end
     end
   end

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

@@ -29,10 +29,6 @@ module LogStruct
         sig { abstract.returns(T.nilable(String)) }
         def referer
         end
-
-        sig { abstract.returns(T.nilable(String)) }
-        def request_id
-        end
       end
     end
   end

data/lib/log_struct/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: logstruct
 version: !ruby/object:Gem::Version
-  version: 0.1.9
+  version: 0.1.11
 platform: ruby
 authors:
 - DocSpring
@@ -271,6 +271,7 @@ files:
 - lib/log_struct/integrations/ahoy.rb
 - lib/log_struct/integrations/carrierwave.rb
 - lib/log_struct/integrations/dotenv.rb
+- lib/log_struct/integrations/event_time.rb
 - lib/log_struct/integrations/good_job.rb
 - lib/log_struct/integrations/good_job/log_subscriber.rb
 - lib/log_struct/integrations/good_job/logger.rb
@@ -281,6 +282,9 @@ files:
 - lib/log_struct/integrations/rack.rb
 - lib/log_struct/integrations/rack_error_handler.rb
 - lib/log_struct/integrations/rack_error_handler/middleware.rb
+- lib/log_struct/integrations/rack_setup.rb
+- lib/log_struct/integrations/request_context.rb
+- lib/log_struct/integrations/request_context/middleware.rb
 - lib/log_struct/integrations/shrine.rb
 - lib/log_struct/integrations/sidekiq.rb
 - lib/log_struct/integrations/sidekiq/logger.rb
@@ -355,6 +359,7 @@ files:
 - lib/log_struct/semantic_logger/setup.rb
 - lib/log_struct/shared/add_request_fields.rb
 - lib/log_struct/shared/interfaces/additional_data_field.rb
+- lib/log_struct/shared/interfaces/common_field_base.rb
 - lib/log_struct/shared/interfaces/common_fields.rb
 - lib/log_struct/shared/interfaces/public_common_fields.rb
 - lib/log_struct/shared/interfaces/request_fields.rb