logstruct 0.1.10 → 0.1.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b138e5ba6e0739ee31d032606f4d7508463deeee00b64e3a870d34d4316e7567
-  data.tar.gz: f36bc4a9cb5ee2ab42b77a581efd1b28c7c23a75191429ac5b5926023d33a594
+  metadata.gz: 90d690080da4286690ca86f0d9eb5b9514483f2324898f07912d66015ec4269d
+  data.tar.gz: df38c5f2434cc5afae25606f77ab2d9a532c9d77c58f81bd558824907ed66418
 SHA512:
-  metadata.gz: c06589605729de5ac9ea44694e82712d2d175201adab6052b6eff1a2ae2cc8cc6b476ed7200d1fa6bf6a79db6eb280847b4ca34559a501bc327129db4574acfe
-  data.tar.gz: 992fc803c47c57367ca906179bf9b356618e42bf840ac6a3de4b7296d90be0db8d513177c57643e1564967624f444d0af00f2582844e4d68825a03f8e911ac37
+  metadata.gz: f654b8b6b7ecf8114c08d4c2b3f9d0f97160bfbd44f60b89ffb08001fed4b186bf7c9697ea8ca1b9ac2d25071f481637e4b050ab4be01efac286d793c12cb7ff
+  data.tar.gz: 88f8fcf0c87b5e2ccd96152d8abb3de94aaeb952879a37c4cb4fdb84fa9fa858d7fb230f50a8e4d440e30e3a6746cb6bb7b0dc3abdd1dc5f7d95ddfbfed18f0b

data/CHANGELOG.md

@@ -9,6 +9,18 @@ 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

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

@@ -17,10 +17,13 @@ module LogStruct
         sig { params(env: T.untyped).returns(T.untyped) }
         def call(env)
           request = ::ActionDispatch::Request.new(env)
-          ::SemanticLogger.push_named_tags(request_id: request.request_id)
+          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

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

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: logstruct
 version: !ruby/object:Gem::Version
-  version: 0.1.10
+  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,7 @@ 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
@@ -357,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