logstruct 0.0.2 → 0.1.1

data/lib/log_struct/log/shrine/upload.rb

@@ -0,0 +1,105 @@
+# 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 Shrine
+      class Upload < T::Struct
+        # typed: strict
+        # frozen_string_literal: true
+
+        extend T::Sig
+
+        extend T::Sig
+
+        # Shared/common fields
+        const :source, Source::Shrine, default: Source::Shrine
+        const :event, Event, default: Event::Upload
+        const :timestamp, Time, factory: -> { Time.now }
+        const :level, Level, default: Level::Info
+
+        # Event-specific fields
+        const :storage, String
+        const :location, String
+        const :upload_options, T.nilable(T::Hash[Symbol, T.untyped]), default: nil
+        const :options, T.nilable(T::Hash[Symbol, T.untyped]), default: nil
+        const :uploader, T.nilable(String), default: nil
+        const :duration_ms, T.nilable(Float), default: nil
+
+        # Additional data
+        include LogStruct::Log::Interfaces::AdditionalDataField
+        const :additional_data, T.nilable(T::Hash[T.any(String, Symbol), T.untyped]), default: nil
+        include LogStruct::Log::Shared::MergeAdditionalDataFields
+
+        # Request fields (optional)
+
+        # Serialize shared fields
+        include LogStruct::Log::Interfaces::CommonFields
+        include LogStruct::Log::Shared::SerializeCommon
+
+        sig { returns(T::Hash[LogStruct::LogField, T.untyped]) }
+        def self.base_hash
+          {}
+        end
+
+        sig {
+          params(storage: T.untyped,
+            location: T.untyped,
+            upload_options: T.untyped,
+            options: T.untyped,
+            uploader: T.untyped,
+            duration_ms: T.untyped,
+            additional_data: T.untyped,
+            timestamp: T.untyped).returns(T::Hash[LogStruct::LogField, T.untyped])
+        }
+        def self.build(storage:,
+          location:,
+          upload_options: nil,
+          options: nil,
+          uploader: nil,
+          duration_ms: nil,
+          additional_data: nil,
+          timestamp: Time.now)
+          h = base_hash
+          h[LogField::Storage] = storage
+          h[LogField::Location] = location
+          h[LogField::UploadOptions] = upload_options unless upload_options.nil?
+          h[LogField::Options] = options unless options.nil?
+          h[LogField::Uploader] = uploader unless uploader.nil?
+          h[LogField::DurationMs] = duration_ms unless duration_ms.nil?
+          h
+        end
+
+        sig { returns(T::Hash[LogStruct::LogField, T.untyped]) }
+        def to_h
+          self.class.build(
+            storage: storage,
+            location: location,
+            upload_options: upload_options,
+            options: options,
+            uploader: uploader,
+            duration_ms: duration_ms,
+            additional_data: additional_data,
+            timestamp: timestamp
+          )
+        end
+      end
+    end
+  end
+end

data/lib/log_struct/log/shrine.rb

@@ -1,70 +1,13 @@
 # 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"
-
-module LogStruct
-  module Log
-    # Shrine log entry for structured logging
-    class Shrine < T::Struct
-      extend T::Sig
-
-      include Interfaces::CommonFields
-      include Interfaces::AdditionalDataField
-      include SerializeCommon
-      include MergeAdditionalDataFields
-
-      ShrineEvent = T.type_alias {
-        T.any(
-          Event::Upload,
-          Event::Download,
-          Event::Delete,
-          Event::Metadata,
-          Event::Exist,
-          Event::Unknown
-        )
-      }
-
-      # Common fields
-      const :source, Source::Shrine, default: T.let(Source::Shrine, Source::Shrine)
-      const :event, ShrineEvent
-      const :timestamp, Time, factory: -> { Time.now }
-      const :level, Level, default: T.let(Level::Info, Level)
-
-      # Shrine-specific fields
-      const :storage, T.nilable(String), default: nil
-      const :location, T.nilable(String), default: nil
-      const :upload_options, T.nilable(T::Hash[Symbol, T.untyped]), default: nil
-      const :download_options, T.nilable(T::Hash[Symbol, T.untyped]), default: nil
-      const :options, T.nilable(T::Hash[Symbol, T.untyped]), default: nil
-      const :uploader, T.nilable(String), default: nil
-      const :duration, T.nilable(Float), default: nil
-      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 Shrine-specific fields if they're present
-        hash[LOG_KEYS.fetch(:storage)] = storage if storage
-        hash[LOG_KEYS.fetch(:location)] = location if location
-        hash[LOG_KEYS.fetch(:upload_options)] = upload_options if upload_options
-        hash[LOG_KEYS.fetch(:download_options)] = download_options if download_options
-        hash[LOG_KEYS.fetch(:options)] = options if options
-        hash[LOG_KEYS.fetch(:uploader)] = uploader if uploader
-        hash[LOG_KEYS.fetch(:duration)] = duration if duration
-
-        hash
-      end
-    end
-  end
-end
+# 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 "shrine/upload"
+require_relative "shrine/download"
+require_relative "shrine/delete"
+require_relative "shrine/metadata"
+require_relative "shrine/exist"

data/lib/log_struct/log/sidekiq.rb

@@ -1,49 +1,88 @@
 # typed: strict
 # frozen_string_literal: true
 
-require_relative "interfaces/common_fields"
-require_relative "shared/serialize_common"
+# 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
-    # Sidekiq log entry for structured logging
     class Sidekiq < T::Struct
-      extend T::Sig
+      # typed: strict
+      # frozen_string_literal: true
 
-      include Interfaces::CommonFields
-      include SerializeCommon
+      extend T::Sig
 
-      # Define valid event types for Sidekiq (currently only Log is used)
-      SidekiqEvent = T.type_alias { Event::Log }
+      extend T::Sig
 
-      # Common fields
-      const :source, Source::Sidekiq, default: T.let(Source::Sidekiq, Source::Sidekiq)
-      const :event, SidekiqEvent, default: T.let(Event::Log, SidekiqEvent)
+      # Shared/common fields
+      const :source, Source::Sidekiq, default: Source::Sidekiq
+      const :event, Event, default: Event::Log
       const :timestamp, Time, factory: -> { Time.now }
-      const :level, Level, default: T.let(Level::Info, Level)
+      const :level, Level, default: Level::Info
 
-      # Sidekiq-specific fields
-      const :process_id, T.nilable(Integer), default: nil
-      const :thread_id, T.nilable(T.any(Integer, String)), default: nil
+      # Event-specific fields
       const :message, T.nilable(String), default: nil
       const :context, T.nilable(T::Hash[Symbol, T.untyped]), default: nil
+      const :process_id, T.nilable(Integer), default: nil
+      const :thread_id, T.nilable(T.any(Integer, String)), default: nil
+
+      # Additional data
+
+      # Request fields (optional)
 
-      # 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)
+      # Serialize shared fields
+      include LogStruct::Log::Interfaces::CommonFields
+      include LogStruct::Log::Shared::SerializeCommon
 
-        # Add Sidekiq-specific fields if they're present
-        hash[LOG_KEYS.fetch(:message)] = message if message
-        hash[LOG_KEYS.fetch(:context)] = context if context
-        hash[LOG_KEYS.fetch(:process_id)] = process_id if process_id
-        hash[LOG_KEYS.fetch(:thread_id)] = thread_id if thread_id
+      sig { returns(T::Hash[LogStruct::LogField, T.untyped]) }
+      def self.base_hash
+        {}
+      end
+
+      sig {
+        params(message: T.untyped,
+          context: T.untyped,
+          process_id: T.untyped,
+          thread_id: T.untyped,
+          additional_data: T.untyped,
+          timestamp: T.untyped).returns(T::Hash[LogStruct::LogField, T.untyped])
+      }
+      def self.build(message: nil,
+        context: nil,
+        process_id: nil,
+        thread_id: nil,
+        additional_data: nil,
+        timestamp: Time.now)
+        h = base_hash
+        h[LogField::Message] = message unless message.nil?
+        h[LogField::Context] = context unless context.nil?
+        h[LogField::ProcessId] = process_id unless process_id.nil?
+        h[LogField::ThreadId] = thread_id unless thread_id.nil?
+        h
+      end
 
-        hash
+      sig { returns(T::Hash[LogStruct::LogField, T.untyped]) }
+      def to_h
+        self.class.build(
+          message: message,
+          context: context,
+          process_id: process_id,
+          thread_id: thread_id,
+          timestamp: timestamp
+        )
       end
     end
   end

data/lib/log_struct/log/sql.rb

@@ -1,125 +1,132 @@
 # 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 "../enums/log_field"
 
 module LogStruct
   module Log
-    # SQL Query Log Structure
-    #
-    # Captures detailed information about SQL queries executed through ActiveRecord.
-    # This provides structured logging for database operations, including:
-    # - Query text and operation name
-    # - Execution timing and performance metrics
-    # - Row counts and connection information
-    # - Safely filtered bind parameters
-    #
-    # ## Use Cases:
-    # - Development debugging of N+1 queries
-    # - Production performance monitoring
-    # - Database query analysis and optimization
-    # - Audit trails for data access patterns
-    #
-    # ## Security:
-    # - SQL queries are safe (always parameterized with ?)
-    # - Bind parameters are filtered through LogStruct's param filters
-    # - Sensitive data like passwords, tokens are automatically scrubbed
-    #
-    # ## Example Usage:
-    #
-    # ```ruby
-    # # Automatically captured when SQL query integration is enabled
-    # LogStruct.config.integrations.enable_sql_logging = true
-    #
-    # # Manual logging (rare)
-    # sql_log = LogStruct::Log::SQL.new(
-    #   message: "User lookup query",
-    #   sql: "SELECT * FROM users WHERE id = ?",
-    #   name: "User Load",
-    #   duration: 2.3,
-    #   row_count: 1,
-    #   bind_params: [123]
-    # )
-    # LogStruct.info(sql_log)
-    # ```
     class SQL < T::Struct
+      # typed: strict
+      # frozen_string_literal: true
+
       extend T::Sig
-      include Interfaces::CommonFields
-      include Interfaces::AdditionalDataField
-      include SerializeCommon
-      include MergeAdditionalDataFields
 
-      SQLEvent = T.type_alias {
-        Event::Database
-      }
+      extend T::Sig
 
-      # Common fields
-      const :source, Source, default: T.let(Source::App, Source)
-      const :event, SQLEvent, default: T.let(Event::Database, SQLEvent)
-      const :level, Level, default: T.let(Level::Info, Level)
+      # Shared/common fields
+      const :source, Source::App, default: Source::App
+      const :event, Event, default: Event::Database
       const :timestamp, Time, factory: -> { Time.now }
-      const :message, String
+      const :level, Level, default: Level::Info
 
-      # The SQL query that was executed (parameterized, safe to log)
+      # Event-specific fields
+      const :message, String
       const :sql, String
-
-      # The name of the database operation (e.g., "User Load", "Post Create")
       const :name, String
+      const :duration_ms, Float
+      const :row_count, T.nilable(Integer), default: nil
+      const :adapter, T.nilable(String), default: nil
+      const :bind_params, T.nilable(T::Array[T.untyped]), default: nil
+      const :database_name, T.nilable(String), default: nil
+      const :connection_pool_size, T.nilable(Integer), default: nil
+      const :active_connections, T.nilable(Integer), default: nil
+      const :operation_type, T.nilable(String), default: nil
+      const :table_names, 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
 
-      # Duration of the query execution in milliseconds
-      const :duration, Float
-
-      # Number of rows affected or returned by the query
-      const :row_count, T.nilable(Integer)
-
-      # Database connection information (adapter name)
-      const :connection_adapter, T.nilable(String)
-
-      # Filtered bind parameters (sensitive data removed)
-      const :bind_params, T.nilable(T::Array[T.untyped])
-
-      # Database name (if available)
-      const :database_name, T.nilable(String)
-
-      # Connection pool size information (for monitoring)
-      const :connection_pool_size, T.nilable(Integer)
-
-      # Active connection count (for monitoring)
-      const :active_connections, T.nilable(Integer)
-
-      # SQL operation type (SELECT, INSERT, UPDATE, DELETE, etc.)
-      const :operation_type, T.nilable(String)
-
-      # Table names involved in the query (extracted from SQL)
-      const :table_names, T.nilable(T::Array[String])
-
-      # Allow additional custom 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 SQL-specific fields using LOG_KEYS mapping for consistency
-        hash[LOG_KEYS.fetch(:message)] = message
-        hash[LOG_KEYS.fetch(:sql)] = sql
-        hash[LOG_KEYS.fetch(:name)] = name
-        hash[LOG_KEYS.fetch(:duration)] = duration
-        hash[LOG_KEYS.fetch(:row_count)] = row_count
-        hash[LOG_KEYS.fetch(:connection_adapter)] = connection_adapter
-        hash[LOG_KEYS.fetch(:bind_params)] = bind_params
-        hash[LOG_KEYS.fetch(:database_name)] = database_name
-        hash[LOG_KEYS.fetch(:connection_pool_size)] = connection_pool_size
-        hash[LOG_KEYS.fetch(:active_connections)] = active_connections
-        hash[LOG_KEYS.fetch(:operation_type)] = operation_type
-        hash[LOG_KEYS.fetch(:table_names)] = table_names
+      sig {
+        params(message: T.untyped,
+          sql: T.untyped,
+          name: T.untyped,
+          duration_ms: T.untyped,
+          row_count: T.untyped,
+          adapter: T.untyped,
+          bind_params: T.untyped,
+          database_name: T.untyped,
+          connection_pool_size: T.untyped,
+          active_connections: T.untyped,
+          operation_type: T.untyped,
+          table_names: T.untyped,
+          additional_data: T.untyped,
+          timestamp: T.untyped).returns(T::Hash[LogStruct::LogField, T.untyped])
+      }
+      def self.build(message:,
+        sql:,
+        name:,
+        duration_ms:,
+        row_count: nil,
+        adapter: nil,
+        bind_params: nil,
+        database_name: nil,
+        connection_pool_size: nil,
+        active_connections: nil,
+        operation_type: nil,
+        table_names: nil,
+        additional_data: nil,
+        timestamp: Time.now)
+        h = base_hash
+        h[LogField::Message] = message
+        h[LogField::Sql] = sql
+        h[LogField::Name] = name
+        h[LogField::DurationMs] = duration_ms
+        h[LogField::RowCount] = row_count unless row_count.nil?
+        h[LogField::Adapter] = adapter unless adapter.nil?
+        h[LogField::BindParams] = bind_params unless bind_params.nil?
+        h[LogField::DatabaseName] = database_name unless database_name.nil?
+        h[LogField::ConnectionPoolSize] = connection_pool_size unless connection_pool_size.nil?
+        h[LogField::ActiveConnections] = active_connections unless active_connections.nil?
+        h[LogField::OperationType] = operation_type unless operation_type.nil?
+        h[LogField::TableNames] = table_names unless table_names.nil?
+        h
+      end
 
-        hash
+      sig { returns(T::Hash[LogStruct::LogField, T.untyped]) }
+      def to_h
+        self.class.build(
+          message: message,
+          sql: sql,
+          name: name,
+          duration_ms: duration_ms,
+          row_count: row_count,
+          adapter: adapter,
+          bind_params: bind_params,
+          database_name: database_name,
+          connection_pool_size: connection_pool_size,
+          active_connections: active_connections,
+          operation_type: operation_type,
+          table_names: table_names,
+          additional_data: additional_data,
+          timestamp: timestamp
+        )
       end
     end
   end

data/lib/log_struct/log.rb

@@ -1,43 +1,42 @@
 # typed: strict
 # frozen_string_literal: true
 
-# Common Enums
+# Common enums and shared interfaces
 require_relative "enums/source"
 require_relative "enums/event"
 require_relative "enums/level"
+require_relative "enums/log_field"
+require_relative "log/interfaces/public_common_fields"
+require_relative "log/shared/serialize_common_public"
 
-# Log Structs
-require_relative "log/carrierwave"
-require_relative "log/action_mailer"
-require_relative "log/active_storage"
-require_relative "log/active_job"
-require_relative "log/error"
-require_relative "log/good_job"
-require_relative "log/plain"
-require_relative "log/request"
-require_relative "log/security"
-require_relative "log/shrine"
-require_relative "log/sidekiq"
-require_relative "log/sql"
+# Dynamically require all top-level log structs under log/*
+# Nested per-event files are required by their parent files.
+Dir[File.join(__dir__, "log", "*.rb")].sort.each do |file|
+  require file
+end
 
 module LogStruct
-  # Type aliases for all possible log types
-  # This should be updated whenever a new log type is added
-  # (Can't use sealed! unless we want to put everything in one giant file.)
-  LogClassType = T.type_alias do
-    T.any(
-      T.class_of(LogStruct::Log::CarrierWave),
-      T.class_of(LogStruct::Log::ActionMailer),
-      T.class_of(LogStruct::Log::ActiveStorage),
-      T.class_of(LogStruct::Log::ActiveJob),
-      T.class_of(LogStruct::Log::Error),
-      T.class_of(LogStruct::Log::GoodJob),
-      T.class_of(LogStruct::Log::Plain),
-      T.class_of(LogStruct::Log::Request),
-      T.class_of(LogStruct::Log::Security),
-      T.class_of(LogStruct::Log::Shrine),
-      T.class_of(LogStruct::Log::Sidekiq),
-      T.class_of(LogStruct::Log::SQL)
-    )
+  module Log
+    extend T::Sig
+
+    # Build an Error log from an exception with optional context and timestamp
+    sig do
+      params(
+        source: Source,
+        ex: StandardError,
+        additional_data: T::Hash[T.any(String, Symbol), T.untyped],
+        timestamp: Time
+      ).returns(LogStruct::Log::Error)
+    end
+    def self.from_exception(source, ex, additional_data = {}, timestamp = Time.now)
+      LogStruct::Log::Error.new(
+        source: source,
+        err_class: ex.class,
+        message: ex.message,
+        backtrace: ex.backtrace,
+        additional_data: additional_data,
+        timestamp: timestamp
+      )
+    end
   end
 end