logstruct 0.1.0 → 0.1.2

data/lib/log_struct/log/good_job.rb

@@ -1,150 +1,49 @@
 # typed: strict
 # frozen_string_literal: true
 
-require_relative "interfaces/common_fields"
-require_relative "interfaces/additional_data_field"
-require_relative "shared/serialize_common"
-require_relative "shared/merge_additional_data_fields"
-require_relative "../enums/source"
-require_relative "../enums/event"
-require_relative "../enums/level"
-require_relative "../log_keys"
+# AUTO-GENERATED: DO NOT EDIT
+# Generated by scripts/generate_structs.rb
+# Schemas dir: schemas/log_sources/
+# Template: tools/codegen/templates/sorbet/source_parent.rb.erb
+
+require_relative "good_job/log"
+require_relative "good_job/enqueue"
+require_relative "good_job/start"
+require_relative "good_job/finish"
+require_relative "good_job/error"
+require_relative "good_job/schedule"
 
 module LogStruct
   module Log
-    # GoodJob log entry for structured logging
-    #
-    # GoodJob is a PostgreSQL-based ActiveJob backend that provides reliable,
-    # scalable job processing for Rails applications. This log class captures
-    # GoodJob-specific events including job execution, database operations,
-    # error handling, and performance metrics.
-    #
-    # ## Key Features Logged:
-    # - Job execution lifecycle (enqueue, start, finish, retry)
-    # - Database-backed job persistence events
-    # - Error handling and retry logic
-    # - Job batching and bulk operations
-    # - Performance metrics and timing data
-    # - Thread and process information
-    #
-    # ## Usage Examples:
-    #
-    # ```ruby
-    # # Job execution logging
-    # LogStruct::Log::GoodJob.new(
-    #   event: Event::Start,
-    #   job_id: "job_123",
-    #   job_class: "UserNotificationJob",
-    #   queue_name: "default",
-    #   execution_time: 1.5
-    # )
-    #
-    # # Error logging
-    # LogStruct::Log::GoodJob.new(
-    #   event: Event::Error,
-    #   job_id: "job_123",
-    #   error_class: "StandardError",
-    #   error_message: "Connection failed"
-    # )
-    # ```
-    class GoodJob < T::Struct
-      extend T::Sig
-
-      include Interfaces::CommonFields
-      include Interfaces::AdditionalDataField
-      include SerializeCommon
-      include MergeAdditionalDataFields
-
-      # Valid event types for GoodJob operations
-      GoodJobEvent = T.type_alias {
-        T.any(
-          Event::Log,         # General logging
-          Event::Enqueue,     # Job queued
-          Event::Start,       # Job execution started
-          Event::Finish,      # Job completed successfully
-          Event::Error,       # Job failed with error
-          Event::Schedule     # Job scheduled for future execution
-        )
-      }
-
-      # Common fields
-      const :source, Source::Job, default: T.let(Source::Job, Source::Job)
-      const :event, GoodJobEvent
-      const :timestamp, Time, factory: -> { Time.now }
-      const :level, Level, default: T.let(Level::Info, Level)
-
-      # Job identification fields
-      const :job_id, T.nilable(String), default: nil
-      const :job_class, T.nilable(String), default: nil
-      const :queue_name, T.nilable(String), default: nil
-      const :batch_id, T.nilable(String), default: nil
-      const :job_label, T.nilable(String), default: nil
-
-      # Job execution context
-      const :arguments, T.nilable(T::Array[T.untyped]), default: nil
-      const :executions, T.nilable(Integer), default: nil
-      const :exception_executions, T.nilable(Integer), default: nil
-      const :execution_time, T.nilable(Float), default: nil
-      const :scheduled_at, T.nilable(Time), default: nil
-
-      # Error information
-      const :error_class, T.nilable(String), default: nil
-      const :error_message, T.nilable(String), default: nil
-      const :error_backtrace, T.nilable(T::Array[String]), default: nil
-
-      # GoodJob-specific metadata
-      const :process_id, T.nilable(Integer), default: nil
-      const :thread_id, T.nilable(String), default: nil
-      const :priority, T.nilable(Integer), default: nil
-      const :cron_key, T.nilable(String), default: nil
-      const :database_connection_name, T.nilable(String), default: nil
-
-      # Performance and metrics
-      const :wait_time, T.nilable(Float), default: nil
-      const :run_time, T.nilable(Float), default: nil
-      const :finished_at, T.nilable(Time), default: nil
-
-      # Additional contextual data
-      const :additional_data, T::Hash[Symbol, T.untyped], default: {}
-
-      # Convert the log entry to a hash for serialization
-      sig { override.params(strict: T::Boolean).returns(T::Hash[Symbol, T.untyped]) }
-      def serialize(strict = true)
-        hash = serialize_common(strict)
-        merge_additional_data_fields(hash)
-
-        # Add job identification fields
-        hash[LOG_KEYS.fetch(:job_id)] = job_id if job_id
-        hash[LOG_KEYS.fetch(:job_class)] = job_class if job_class
-        hash[LOG_KEYS.fetch(:queue_name)] = queue_name if queue_name
-        hash[:batch_id] = batch_id if batch_id
-        hash[:job_label] = job_label if job_label
-
-        # Add execution context
-        hash[LOG_KEYS.fetch(:arguments)] = arguments if arguments
-        hash[:executions] = executions if executions
-        hash[:exception_executions] = exception_executions if exception_executions
-        hash[:execution_time] = execution_time if execution_time
-        hash[:scheduled_at] = scheduled_at&.iso8601 if scheduled_at
-
-        # Add error information
-        hash[LOG_KEYS.fetch(:err_class)] = error_class if error_class
-        hash[:error_message] = error_message if error_message
-        hash[LOG_KEYS.fetch(:backtrace)] = error_backtrace if error_backtrace
-
-        # Add GoodJob-specific metadata
-        hash[LOG_KEYS.fetch(:process_id)] = process_id if process_id
-        hash[LOG_KEYS.fetch(:thread_id)] = thread_id if thread_id
-        hash[:priority] = priority if priority
-        hash[:cron_key] = cron_key if cron_key
-        hash[:database_connection_name] = database_connection_name if database_connection_name
-
-        # Add performance metrics
-        hash[:wait_time] = wait_time if wait_time
-        hash[:run_time] = run_time if run_time
-        hash[:finished_at] = finished_at&.iso8601 if finished_at
-
-        hash
+    class GoodJob
+      class BaseFields < T::Struct
+        extend T::Sig
+        const :job_id, T.nilable(String), default: nil
+        const :job_class, T.nilable(String), default: nil
+        const :queue_name, T.nilable(String), default: nil
+        const :arguments, T.nilable(T::Array[T.untyped]), default: nil
+        const :executions, T.nilable(Integer), default: nil
+
+        Kwargs = T.type_alias do
+          {
+            job_id: T.nilable(String),
+            job_class: T.nilable(String),
+            queue_name: T.nilable(String),
+            arguments: T.nilable(T::Array[T.untyped]),
+            executions: T.nilable(Integer)
+          }
+        end
+
+        sig { returns(Kwargs) }
+        def to_kwargs
+          {
+            job_id: job_id,
+            job_class: job_class,
+            queue_name: queue_name,
+            arguments: arguments,
+            executions: executions
+          }
+        end
       end
     end
   end

data/lib/log_struct/log/interfaces/additional_data_field.rb

@@ -1,20 +1,4 @@
 # typed: strict
 # frozen_string_literal: true
 
-module LogStruct
-  module Log
-    module Interfaces
-      # Common interface for logs that include an additional_data field
-      module AdditionalDataField
-        extend T::Sig
-        extend T::Helpers
-
-        interface!
-
-        # Additional data field for extra context
-        sig { abstract.returns(T::Hash[Symbol, T.untyped]) }
-        def additional_data; end
-      end
-    end
-  end
-end
+require "log_struct/shared/interfaces/additional_data_field"

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

@@ -1,42 +1,4 @@
 # typed: strict
 # frozen_string_literal: true
 
-require_relative "../../enums/source"
-require_relative "../../enums/event"
-require_relative "../../enums/level"
-
-module LogStruct
-  module Log
-    module Interfaces
-      # Common interface that all log entry types must implement
-      module CommonFields
-        extend T::Sig
-        extend T::Helpers
-
-        interface!
-
-        # The source of the log entry (JSON property: src)
-        sig { abstract.returns(Source) }
-        def source; end
-
-        # The event type of the log entry (JSON property: evt)
-        sig { abstract.returns(Event) }
-        def event; end
-
-        # The log level (JSON property: lvl)
-        sig { abstract.returns(Level) }
-        def level; end
-
-        # The timestamp of the log entry (JSON property: ts)
-        sig { abstract.returns(Time) }
-        def timestamp; end
-
-        # All logs must define a custom serialize method
-        # If the class is a T::Struct that responds to serialize then we can be sure
-        # we're getting symbols as keys and don't need to call #serialize.deep_symbolize_keys
-        sig { abstract.params(strict: T::Boolean).returns(T::Hash[Symbol, T.untyped]) }
-        def serialize(strict = true); end
-      end
-    end
-  end
-end
+require "log_struct/shared/interfaces/common_fields"

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

@@ -1,31 +1,4 @@
 # typed: strict
 # frozen_string_literal: true
 
-require_relative "../../enums/level"
-
-module LogStruct
-  module Log
-    module Interfaces
-      # Public interface for custom app log types.
-      # Allows String/Symbol for source and event so apps can define their own domains.
-      module PublicCommonFields
-        extend T::Sig
-        extend T::Helpers
-
-        interface!
-
-        # Log level (defaults to Info in most structs)
-        sig { abstract.returns(Level) }
-        def level; end
-
-        # Timestamp for the entry
-        sig { abstract.returns(Time) }
-        def timestamp; end
-
-        # Custom serialize method returning symbol-keyed hash
-        sig { abstract.params(strict: T::Boolean).returns(T::Hash[Symbol, T.untyped]) }
-        def serialize(strict = true); end
-      end
-    end
-  end
-end
+require "log_struct/shared/interfaces/public_common_fields"

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

@@ -1,36 +1,4 @@
 # typed: strict
 # frozen_string_literal: true
 
-module LogStruct
-  module Log
-    module Interfaces
-      # Common interface for request-related fields
-      # Used by both Request and Security logs
-      module RequestFields
-        extend T::Sig
-        extend T::Helpers
-
-        interface!
-
-        # Common request fields
-        sig { abstract.returns(T.nilable(String)) }
-        def path; end
-
-        sig { abstract.returns(T.nilable(String)) }
-        def http_method; end
-
-        sig { abstract.returns(T.nilable(String)) }
-        def source_ip; end
-
-        sig { abstract.returns(T.nilable(String)) }
-        def user_agent; end
-
-        sig { abstract.returns(T.nilable(String)) }
-        def referer; end
-
-        sig { abstract.returns(T.nilable(String)) }
-        def request_id; end
-      end
-    end
-  end
-end
+require "log_struct/shared/interfaces/request_fields"

data/lib/log_struct/log/plain.rb

@@ -1,52 +1,77 @@
 # typed: strict
 # frozen_string_literal: true
 
-require_relative "interfaces/common_fields"
-require_relative "interfaces/additional_data_field"
-require_relative "shared/serialize_common"
-require_relative "shared/merge_additional_data_fields"
+# AUTO-GENERATED: DO NOT EDIT
+# Generated by scripts/generate_structs.rb
+# Schemas dir: schemas/log_sources/
+# Template: tools/codegen/templates/sorbet/event.rb.erb
+
+require "log_struct/shared/interfaces/common_fields"
+require "log_struct/shared/interfaces/additional_data_field"
+require "log_struct/shared/interfaces/request_fields"
+require "log_struct/shared/shared/serialize_common"
+require "log_struct/shared/shared/merge_additional_data_fields"
+require "log_struct/shared/shared/add_request_fields"
 require_relative "../enums/source"
 require_relative "../enums/event"
 require_relative "../enums/level"
-require_relative "../log_keys"
+require_relative "../enums/log_field"
 
 module LogStruct
   module Log
-    # Plain log entry for structured logging
     class Plain < T::Struct
-      extend T::Sig
+      # typed: strict
+      # frozen_string_literal: true
 
-      include Interfaces::CommonFields
-      include Interfaces::AdditionalDataField
-      include SerializeCommon
-      include MergeAdditionalDataFields
+      extend T::Sig
 
-      PlainEvent = T.type_alias {
-        Event::Log
-      }
+      extend T::Sig
 
-      # Common fields
-      const :source, Source, default: T.let(Source::App, Source)
-      const :event, PlainEvent, default: T.let(Event::Log, PlainEvent)
-      const :level, Level, default: T.let(Level::Info, Level)
+      # Shared/common fields
+      const :source, Source::App, default: Source::App
+      const :event, Event, default: Event::Log
       const :timestamp, Time, factory: -> { Time.now }
+      const :level, Level, default: Level::Info
+
+      # Event-specific fields
+      const :message, T.untyped
+
+      # Additional data
+      include LogStruct::Log::Interfaces::AdditionalDataField
+      const :additional_data, T.nilable(T::Hash[T.any(String, Symbol), T.untyped]), default: nil
+      include LogStruct::Log::Shared::MergeAdditionalDataFields
+
+      # Request fields (optional)
+
+      # Serialize shared fields
+      include LogStruct::Log::Interfaces::CommonFields
+      include LogStruct::Log::Shared::SerializeCommon
+
+      sig { returns(T::Hash[LogStruct::LogField, T.untyped]) }
+      def self.base_hash
+        {}
+      end
+
+      sig {
+        params(message: T.untyped,
+          additional_data: T.untyped,
+          timestamp: T.untyped).returns(T::Hash[LogStruct::LogField, T.untyped])
+      }
+      def self.build(message:,
+        additional_data: nil,
+        timestamp: Time.now)
+        h = base_hash
+        h[LogField::Message] = message
+        h
+      end
 
-      # Plain log messages can be any type (String, Number, Array, Hash, etc.)
-      # Developers might do something like Rails.logger.info(123) or Rails.logger.info(@variable)
-      # when debugging, or gems might send all kinds of random stuff to the logger.
-      # We don't want to crash with a type error in any of these cases.
-      const :message, T.untyped # rubocop:disable Sorbet/ForbidUntypedStructProps
-
-      # Allow people to submit additional data
-      const :additional_data, T::Hash[Symbol, T.untyped], default: {}
-
-      # Convert the log entry to a hash for serialization
-      sig { override.params(strict: T::Boolean).returns(T::Hash[Symbol, T.untyped]) }
-      def serialize(strict = true)
-        hash = serialize_common(strict)
-        merge_additional_data_fields(hash)
-        hash[LOG_KEYS.fetch(:message)] = message
-        hash
+      sig { returns(T::Hash[LogStruct::LogField, T.untyped]) }
+      def to_h
+        self.class.build(
+          message: message,
+          additional_data: additional_data,
+          timestamp: timestamp
+        )
       end
     end
   end

data/lib/log_struct/log/puma/shutdown.rb

@@ -0,0 +1,80 @@
+# typed: strict
+# frozen_string_literal: true
+
+# AUTO-GENERATED: DO NOT EDIT
+# Generated by scripts/generate_structs.rb
+# Schemas dir: schemas/log_sources/
+# Template: tools/codegen/templates/sorbet/event.rb.erb
+
+require "log_struct/shared/interfaces/common_fields"
+require "log_struct/shared/interfaces/additional_data_field"
+require "log_struct/shared/interfaces/request_fields"
+require "log_struct/shared/shared/serialize_common"
+require "log_struct/shared/shared/merge_additional_data_fields"
+require "log_struct/shared/shared/add_request_fields"
+require_relative "../../enums/source"
+require_relative "../../enums/event"
+require_relative "../../enums/level"
+require_relative "../../enums/log_field"
+
+module LogStruct
+  module Log
+    class Puma
+      class Shutdown < T::Struct
+        # typed: strict
+        # frozen_string_literal: true
+
+        extend T::Sig
+
+        extend T::Sig
+
+        # Shared/common fields
+        const :source, Source::Puma, default: Source::Puma
+        const :event, Event, default: Event::Shutdown
+        const :timestamp, Time, factory: -> { Time.now }
+        const :level, Level, default: Level::Info
+
+        # Event-specific fields
+        const :process_id, T.nilable(Integer), default: nil
+
+        # Additional data
+        include LogStruct::Log::Interfaces::AdditionalDataField
+        const :additional_data, T.nilable(T::Hash[T.any(String, Symbol), T.untyped]), default: nil
+        include LogStruct::Log::Shared::MergeAdditionalDataFields
+
+        # Request fields (optional)
+
+        # Serialize shared fields
+        include LogStruct::Log::Interfaces::CommonFields
+        include LogStruct::Log::Shared::SerializeCommon
+
+        sig { returns(T::Hash[LogStruct::LogField, T.untyped]) }
+        def self.base_hash
+          {}
+        end
+
+        sig {
+          params(process_id: T.untyped,
+            additional_data: T.untyped,
+            timestamp: T.untyped).returns(T::Hash[LogStruct::LogField, T.untyped])
+        }
+        def self.build(process_id: nil,
+          additional_data: nil,
+          timestamp: Time.now)
+          h = base_hash
+          h[LogField::ProcessId] = process_id unless process_id.nil?
+          h
+        end
+
+        sig { returns(T::Hash[LogStruct::LogField, T.untyped]) }
+        def to_h
+          self.class.build(
+            process_id: process_id,
+            additional_data: additional_data,
+            timestamp: timestamp
+          )
+        end
+      end
+    end
+  end
+end

data/lib/log_struct/log/puma/start.rb

@@ -0,0 +1,120 @@
+# typed: strict
+# frozen_string_literal: true
+
+# AUTO-GENERATED: DO NOT EDIT
+# Generated by scripts/generate_structs.rb
+# Schemas dir: schemas/log_sources/
+# Template: tools/codegen/templates/sorbet/event.rb.erb
+
+require "log_struct/shared/interfaces/common_fields"
+require "log_struct/shared/interfaces/additional_data_field"
+require "log_struct/shared/interfaces/request_fields"
+require "log_struct/shared/shared/serialize_common"
+require "log_struct/shared/shared/merge_additional_data_fields"
+require "log_struct/shared/shared/add_request_fields"
+require_relative "../../enums/source"
+require_relative "../../enums/event"
+require_relative "../../enums/level"
+require_relative "../../enums/log_field"
+
+module LogStruct
+  module Log
+    class Puma
+      class Start < T::Struct
+        # typed: strict
+        # frozen_string_literal: true
+
+        extend T::Sig
+
+        extend T::Sig
+
+        # Shared/common fields
+        const :source, Source::Puma, default: Source::Puma
+        const :event, Event, default: Event::Start
+        const :timestamp, Time, factory: -> { Time.now }
+        const :level, Level, default: Level::Info
+
+        # Event-specific fields
+        const :mode, T.nilable(String), default: nil
+        const :puma_version, T.nilable(String), default: nil
+        const :puma_codename, T.nilable(String), default: nil
+        const :ruby_version, T.nilable(String), default: nil
+        const :min_threads, T.nilable(Integer), default: nil
+        const :max_threads, T.nilable(Integer), default: nil
+        const :environment, T.nilable(String), default: nil
+        const :process_id, T.nilable(Integer), default: nil
+        const :listening_addresses, T.nilable(T::Array[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)
+
+        # Serialize shared fields
+        include LogStruct::Log::Interfaces::CommonFields
+        include LogStruct::Log::Shared::SerializeCommon
+
+        sig { returns(T::Hash[LogStruct::LogField, T.untyped]) }
+        def self.base_hash
+          {}
+        end
+
+        sig {
+          params(mode: T.untyped,
+            puma_version: T.untyped,
+            puma_codename: T.untyped,
+            ruby_version: T.untyped,
+            min_threads: T.untyped,
+            max_threads: T.untyped,
+            environment: T.untyped,
+            process_id: T.untyped,
+            listening_addresses: T.untyped,
+            additional_data: T.untyped,
+            timestamp: T.untyped).returns(T::Hash[LogStruct::LogField, T.untyped])
+        }
+        def self.build(mode: nil,
+          puma_version: nil,
+          puma_codename: nil,
+          ruby_version: nil,
+          min_threads: nil,
+          max_threads: nil,
+          environment: nil,
+          process_id: nil,
+          listening_addresses: nil,
+          additional_data: nil,
+          timestamp: Time.now)
+          h = base_hash
+          h[LogField::Mode] = mode unless mode.nil?
+          h[LogField::PumaVersion] = puma_version unless puma_version.nil?
+          h[LogField::PumaCodename] = puma_codename unless puma_codename.nil?
+          h[LogField::RubyVersion] = ruby_version unless ruby_version.nil?
+          h[LogField::MinThreads] = min_threads unless min_threads.nil?
+          h[LogField::MaxThreads] = max_threads unless max_threads.nil?
+          h[LogField::Environment] = environment unless environment.nil?
+          h[LogField::ProcessId] = process_id unless process_id.nil?
+          h[LogField::ListeningAddresses] = listening_addresses unless listening_addresses.nil?
+          h
+        end
+
+        sig { returns(T::Hash[LogStruct::LogField, T.untyped]) }
+        def to_h
+          self.class.build(
+            mode: mode,
+            puma_version: puma_version,
+            puma_codename: puma_codename,
+            ruby_version: ruby_version,
+            min_threads: min_threads,
+            max_threads: max_threads,
+            environment: environment,
+            process_id: process_id,
+            listening_addresses: listening_addresses,
+            additional_data: additional_data,
+            timestamp: timestamp
+          )
+        end
+      end
+    end
+  end
+end

data/lib/log_struct/log/puma.rb

@@ -0,0 +1,10 @@
+# typed: strict
+# frozen_string_literal: true
+
+# AUTO-GENERATED: DO NOT EDIT
+# Generated by scripts/generate_structs.rb
+# Schemas dir: schemas/log_sources/
+# Template: tools/codegen/templates/sorbet/source_parent.rb.erb
+
+require_relative "puma/start"
+require_relative "puma/shutdown"