logstruct 0.1.2 → 0.1.3

data/lib/log_struct/integrations/carrierwave.rb

@@ -53,7 +53,7 @@ module LogStruct
 
           # Log the store operation with structured data
           log_data = Log::CarrierWave::Upload.new(
-            storage: storage.class.name,
+            storage: storage.class.name.split("::").last.downcase.to_sym,
             file_id: identifier,
             filename: file.filename,
             mime_type: file.content_type,
@@ -62,11 +62,9 @@ module LogStruct
             uploader: self.class.name,
             model: model.class.name,
             mount_point: mounted_as.to_s,
-            additional_data: {
-              version: version_name.to_s,
-              store_path: store_path,
-              extension: file.extension
-            }
+            version: version_name.to_s,
+            store_path: store_path,
+            extension: file.extension
           )
 
           ::Rails.logger.info(log_data)
@@ -85,7 +83,7 @@ module LogStruct
 
           # Log the retrieve operation with structured data
           log_data = Log::CarrierWave::Download.new(
-            storage: storage.class.name,
+            storage: storage.class.name.split("::").last.downcase.to_sym,
             file_id: identifier,
             filename: file&.filename,
             mime_type: file&.content_type,
@@ -94,9 +92,9 @@ module LogStruct
             uploader: self.class.name,
             model: model.class.name,
             mount_point: mounted_as.to_s,
-            additional_data: {
-              version: version_name.to_s
-            }
+            version: version_name.to_s,
+            store_path: store_path,
+            extension: file&.extension
           )
 
           ::Rails.logger.info(log_data)

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

@@ -49,7 +49,7 @@ module LogStruct
             **base_fields.to_kwargs,
             scheduled_at: (job&.scheduled_at ? Time.at(job.scheduled_at.to_i) : nil),
             duration_ms: event.duration.to_f,
-            additional_data: {enqueue_caller: job&.enqueue_caller_location},
+            enqueue_caller: job&.enqueue_caller_location,
             timestamp: ts
           ))
         end
@@ -91,7 +91,7 @@ module LogStruct
             finished_at: end_ts,
             process_id: ::Process.pid,
             thread_id: Thread.current.object_id.to_s(36),
-            additional_data: {result: payload[:result]},
+            result: payload[:result]&.to_s,
             timestamp: start_ts
           ))
         end
@@ -109,9 +109,9 @@ module LogStruct
           logger.error(Log::GoodJob::Error.new(
             **base_fields.to_kwargs,
             exception_executions: execution&.exception_executions,
-            err_class: exception&.class&.name,
+            error_class: exception&.class&.name,
             error_message: exception&.message,
-            backtrace: exception&.backtrace&.first(20),
+            backtrace: exception&.backtrace,
             duration_ms: event.duration.to_f,
             process_id: ::Process.pid,
             thread_id: Thread.current.object_id.to_s(36),
@@ -146,7 +146,7 @@ module LogStruct
           Log::GoodJob::BaseFields.new(
             job_id: job&.job_id,
             job_class: job&.job_class,
-            queue_name: job&.queue_name,
+            queue_name: job&.queue_name&.to_sym,
             arguments: job&.arguments,
             executions: execution&.executions
           )

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

@@ -46,11 +46,6 @@ module LogStruct
               end
             end
 
-            # Emit a GoodJob::Log event with context and extra fields as additional_data
-            extras = {}
-            extras[:scheduled_at] = job_context[:scheduled_at] if job_context.key?(:scheduled_at)
-            extras[:priority] = job_context[:priority] if job_context.key?(:priority)
-
             log_struct = Log::GoodJob::Log.new(
               message: message || (block ? block.call : ""),
               process_id: ::Process.pid,
@@ -59,7 +54,8 @@ module LogStruct
               job_class: job_context[:job_class],
               queue_name: job_context[:queue_name],
               executions: job_context[:executions],
-              additional_data: extras
+              scheduled_at: job_context[:scheduled_at],
+              priority: job_context[:priority]
             )
 
             super(log_struct, payload, &nil)

data/lib/log_struct/integrations/good_job.rb

@@ -82,7 +82,7 @@ module LogStruct
         if goodjob_module.respond_to?(:on_thread_error=)
           goodjob_module.on_thread_error = ->(exception) do
             log_entry = LogStruct::Log::GoodJob::Error.new(
-              err_class: exception.class.name,
+              error_class: exception.class.name,
               error_message: exception.message,
               backtrace: exception.backtrace,
               process_id: ::Process.pid,

data/lib/log_struct/integrations/host_authorization.rb

@@ -3,6 +3,7 @@
 
 require "action_dispatch/middleware/host_authorization"
 require_relative "../enums/event"
+require_relative "../log/security/blocked_host"
 
 module LogStruct
   module Integrations
@@ -34,23 +35,6 @@ module LogStruct
         return nil unless config.enabled
         return nil unless config.integrations.enable_host_authorization
 
-        # In test environment, ensure HostAuthorization does not block requests
-        # from the default integration test hosts. Allow all hosts explicitly.
-        if ::Rails.env.test? && ::Rails.application.config.respond_to?(:hosts)
-          begin
-            ::Rails.application.config.hosts << /.*\z/
-          rescue
-            # best-effort; ignore if hosts not configurable
-          end
-          # Additionally, exclude all requests from HostAuthorization in test
-          begin
-            ::Rails.application.config.host_authorization ||= {}
-            ::Rails.application.config.host_authorization[:exclude] = ->(_request) { true }
-          rescue
-            # best-effort
-          end
-        end
-
         # Define the response app as a separate variable to fix block alignment
         response_app = lambda do |env|
           request = ::ActionDispatch::Request.new(env)
@@ -58,32 +42,39 @@ module LogStruct
           # This can be helpful later when reviewing logs.
           blocked_hosts = env["action_dispatch.blocked_hosts"]
 
-          # Create a security error to be handled
-          blocked_host_error = ::ActionController::BadRequest.new(
-            "Blocked host detected: #{request.host}"
-          )
+          # Build allowed_hosts array
+          allowed_hosts_array = T.let(nil, T.nilable(T::Array[String]))
+          if blocked_hosts.respond_to?(:allowed_hosts)
+            allowed_hosts_array = blocked_hosts.allowed_hosts
+          end
+
+          # Get allow_ip_hosts value
+          allow_ip_hosts_value = T.let(nil, T.nilable(T::Boolean))
+          if blocked_hosts.respond_to?(:allow_ip_hosts)
+            allow_ip_hosts_value = blocked_hosts.allow_ip_hosts
+          end
 
-          # Create request context hash
-          context = {
+          # Create structured log entry for blocked host
+          log_entry = LogStruct::Log::Security::BlockedHost.new(
+            message: "Blocked host detected: #{request.host}",
             blocked_host: request.host,
-            client_ip: request.ip,
-            x_forwarded_for: request.x_forwarded_for,
-            http_method: request.method,
             path: request.path,
+            http_method: request.method,
+            source_ip: request.ip,
             user_agent: request.user_agent,
-            allowed_hosts: blocked_hosts.allowed_hosts,
-            allow_ip_hosts: blocked_hosts.allow_ip_hosts
-          }
-
-          # Handle error according to configured mode (log, report, raise)
-          LogStruct.handle_exception(
-            blocked_host_error,
-            source: Source::Security,
-            context: context
+            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
           )
 
+          # Log the blocked host
+          LogStruct.warn(log_entry)
+
           # Use pre-defined headers and response if we are only logging or reporting
-          [FORBIDDEN_STATUS, RESPONSE_HEADERS, [RESPONSE_HTML]]
+          # Dup the headers so they can be modified by downstream middleware
+          [FORBIDDEN_STATUS, RESPONSE_HEADERS.dup, [RESPONSE_HTML]]
         end
 
         # Merge our response_app into existing host_authorization config to preserve excludes

data/lib/log_struct/integrations/lograge.rb

@@ -50,7 +50,7 @@ module LogStruct
                 Log::Request.new(
                   http_method: data[:method]&.to_s,
                   path: data[:path]&.to_s,
-                  format: data[:format]&.to_s,
+                  format: data[:format]&.to_sym,
                   controller: data[:controller]&.to_s,
                   action: data[:action]&.to_s,
                   status: status,

data/lib/log_struct/integrations/shrine.rb

@@ -37,50 +37,47 @@ module LogStruct
           end
 
           # Create structured log data
+          # Ensure storage is always a symbol
+          storage_sym = payload[:storage].to_sym
+
           log_data = case event_type
           when Event::Upload
             Log::Shrine::Upload.new(
-              storage: payload[:storage],
+              storage: storage_sym,
               location: payload[:location],
-              uploader: payload[:uploader],
+              uploader: payload[:uploader]&.to_s,
               upload_options: payload[:upload_options],
               options: payload[:options],
-              duration_ms: event.duration,
-              additional_data: payload.except(:storage, :location, :uploader, :upload_options, :options)
+              duration_ms: event.duration.to_f
             )
           when Event::Download
             Log::Shrine::Download.new(
-              storage: payload[:storage],
+              storage: storage_sym,
               location: payload[:location],
-              download_options: payload[:download_options],
-              additional_data: payload.except(:storage, :location, :download_options)
+              download_options: payload[:download_options]
             )
           when Event::Delete
             Log::Shrine::Delete.new(
-              storage: payload[:storage],
-              location: payload[:location],
-              additional_data: payload.except(:storage, :location)
+              storage: storage_sym,
+              location: payload[:location]
             )
           when Event::Metadata
-            Log::Shrine::Metadata.new(
-              storage: payload[:storage],
-              location: payload[:location],
-              metadata: payload[:metadata],
-              additional_data: payload.except(:storage, :location, :metadata)
-            )
+            metadata_params = {
+              storage: storage_sym,
+              metadata: payload[:metadata]
+            }
+            metadata_params[:location] = payload[:location] if payload[:location]
+            Log::Shrine::Metadata.new(**metadata_params)
           when Event::Exist
             Log::Shrine::Exist.new(
-              storage: payload[:storage],
+              storage: storage_sym,
               location: payload[:location],
-              exist: payload[:exist],
-              additional_data: payload.except(:storage, :location, :exist)
+              exist: payload[:exist]
             )
           else
-            Log::Shrine::Metadata.new(
-              storage: payload[:storage],
-              location: payload[:location],
-              metadata: payload[:metadata]
-            )
+            unknown_params = {storage: storage_sym, metadata: payload[:metadata]}
+            unknown_params[:location] = payload[:location] if payload[:location]
+            Log::Shrine::Metadata.new(**unknown_params)
           end
 
           # Pass the structured hash to the logger

data/lib/log_struct/integrations/sidekiq/logger.rb

@@ -23,11 +23,18 @@ module LogStruct
         # Override log methods to create Sidekiq log structs
         %i[debug info warn error fatal].each do |level|
           define_method(level) do |message = nil, payload = nil, &block|
+            # Ensure message is a String (Sidekiq may pass Hash for config logs)
+            msg = if message.nil?
+              block ? block.call.to_s : ""
+            else
+              message.to_s
+            end
+
             # Create a Sidekiq log struct with the message
             log_struct = Log::Sidekiq.new(
               level: LogStruct::Level.from_severity(level.to_s.upcase),
               event: Event::Log,
-              message: message || (block ? block.call : ""),
+              message: msg,
               process_id: ::Process.pid,
               thread_id: Sidekiq.tid,
               context: ::Sidekiq::Context.current || {}

data/lib/log_struct/log/action_mailer/delivered.rb

@@ -9,9 +9,9 @@
 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 "log_struct/shared/serialize_common"
+require "log_struct/shared/merge_additional_data_fields"
+require "log_struct/shared/add_request_fields"
 require_relative "../../enums/source"
 require_relative "../../enums/event"
 require_relative "../../enums/level"
@@ -21,11 +21,6 @@ module LogStruct
   module Log
     class ActionMailer
       class Delivered < T::Struct
-        # typed: strict
-        # frozen_string_literal: true
-
-        extend T::Sig
-
         extend T::Sig
 
         # Shared/common fields
@@ -37,62 +32,32 @@ module LogStruct
         const :to, T.nilable(T::Array[String]), default: nil
         const :from, T.nilable(String), default: nil
         const :subject, T.nilable(String), default: nil
-
-        # Event-specific fields
+        const :message_id, T.nilable(String), default: nil
+        const :mailer_class, T.nilable(String), default: nil
+        const :mailer_action, T.nilable(String), default: nil
+        const :attachment_count, 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 {
-          params(to: T.untyped,
-            from: T.untyped,
-            subject: T.untyped).returns(T::Hash[LogStruct::LogField, T.untyped])
-        }
-        def self.base_hash(to: nil,
-          from: nil,
-          subject: nil)
-          h = {}
+        sig { returns(T::Hash[LogStruct::LogField, T.untyped]) }
+        def to_h
+          h = T.let({}, T::Hash[LogStruct::LogField, T.untyped])
           h[LogField::To] = to unless to.nil?
           h[LogField::From] = from unless from.nil?
           h[LogField::Subject] = subject unless subject.nil?
+          h[LogField::MessageId] = message_id unless message_id.nil?
+          h[LogField::MailerClass] = mailer_class unless mailer_class.nil?
+          h[LogField::MailerAction] = mailer_action unless mailer_action.nil?
+          h[LogField::AttachmentCount] = attachment_count unless attachment_count.nil?
           h
         end
-
-        sig {
-          params(to: T.untyped,
-            from: T.untyped,
-            subject: T.untyped,
-            additional_data: T.untyped,
-            timestamp: T.untyped).returns(T::Hash[LogStruct::LogField, T.untyped])
-        }
-        def self.build(to: nil,
-          from: nil,
-          subject: nil,
-          additional_data: nil,
-          timestamp: Time.now)
-          base_hash(to: to,
-            from: from,
-            subject: subject)
-        end
-
-        sig { returns(T::Hash[LogStruct::LogField, T.untyped]) }
-        def to_h
-          self.class.build(
-            to: to,
-            from: from,
-            subject: subject,
-            additional_data: additional_data,
-            timestamp: timestamp
-          )
-        end
       end
     end
   end

data/lib/log_struct/log/action_mailer/delivery.rb

@@ -9,9 +9,9 @@
 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 "log_struct/shared/serialize_common"
+require "log_struct/shared/merge_additional_data_fields"
+require "log_struct/shared/add_request_fields"
 require_relative "../../enums/source"
 require_relative "../../enums/event"
 require_relative "../../enums/level"
@@ -21,11 +21,6 @@ module LogStruct
   module Log
     class ActionMailer
       class Delivery < T::Struct
-        # typed: strict
-        # frozen_string_literal: true
-
-        extend T::Sig
-
         extend T::Sig
 
         # Shared/common fields
@@ -37,62 +32,32 @@ module LogStruct
         const :to, T.nilable(T::Array[String]), default: nil
         const :from, T.nilable(String), default: nil
         const :subject, T.nilable(String), default: nil
-
-        # Event-specific fields
+        const :message_id, T.nilable(String), default: nil
+        const :mailer_class, T.nilable(String), default: nil
+        const :mailer_action, T.nilable(String), default: nil
+        const :attachment_count, 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 {
-          params(to: T.untyped,
-            from: T.untyped,
-            subject: T.untyped).returns(T::Hash[LogStruct::LogField, T.untyped])
-        }
-        def self.base_hash(to: nil,
-          from: nil,
-          subject: nil)
-          h = {}
+        sig { returns(T::Hash[LogStruct::LogField, T.untyped]) }
+        def to_h
+          h = T.let({}, T::Hash[LogStruct::LogField, T.untyped])
           h[LogField::To] = to unless to.nil?
           h[LogField::From] = from unless from.nil?
           h[LogField::Subject] = subject unless subject.nil?
+          h[LogField::MessageId] = message_id unless message_id.nil?
+          h[LogField::MailerClass] = mailer_class unless mailer_class.nil?
+          h[LogField::MailerAction] = mailer_action unless mailer_action.nil?
+          h[LogField::AttachmentCount] = attachment_count unless attachment_count.nil?
           h
         end
-
-        sig {
-          params(to: T.untyped,
-            from: T.untyped,
-            subject: T.untyped,
-            additional_data: T.untyped,
-            timestamp: T.untyped).returns(T::Hash[LogStruct::LogField, T.untyped])
-        }
-        def self.build(to: nil,
-          from: nil,
-          subject: nil,
-          additional_data: nil,
-          timestamp: Time.now)
-          base_hash(to: to,
-            from: from,
-            subject: subject)
-        end
-
-        sig { returns(T::Hash[LogStruct::LogField, T.untyped]) }
-        def to_h
-          self.class.build(
-            to: to,
-            from: from,
-            subject: subject,
-            additional_data: additional_data,
-            timestamp: timestamp
-          )
-        end
       end
     end
   end

data/lib/log_struct/log/action_mailer/error.rb

@@ -0,0 +1,72 @@
+# 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/serialize_common"
+require "log_struct/shared/merge_additional_data_fields"
+require "log_struct/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 ActionMailer
+      class Error < T::Struct
+        extend T::Sig
+
+        # Shared/common fields
+        const :source, Source::Mailer, default: Source::Mailer
+        const :event, Event, default: Event::Error
+        const :timestamp, Time, factory: -> { Time.now }
+        const :level, Level, default: Level::Info
+
+        const :to, T.nilable(T::Array[String]), default: nil
+        const :from, T.nilable(String), default: nil
+        const :subject, T.nilable(String), default: nil
+        const :message_id, T.nilable(String), default: nil
+        const :mailer_class, T.nilable(String), default: nil
+        const :mailer_action, T.nilable(String), default: nil
+        const :attachment_count, T.nilable(Integer), default: nil
+
+        # Event-specific fields
+        const :error_class, T.class_of(StandardError)
+        const :message, String
+        const :backtrace, 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
+
+        # Serialize shared fields
+        include LogStruct::Log::Interfaces::CommonFields
+        include LogStruct::Log::Shared::SerializeCommon
+
+        sig { returns(T::Hash[LogStruct::LogField, T.untyped]) }
+        def to_h
+          h = T.let({}, T::Hash[LogStruct::LogField, T.untyped])
+          h[LogField::To] = to unless to.nil?
+          h[LogField::From] = from unless from.nil?
+          h[LogField::Subject] = subject unless subject.nil?
+          h[LogField::MessageId] = message_id unless message_id.nil?
+          h[LogField::MailerClass] = mailer_class unless mailer_class.nil?
+          h[LogField::MailerAction] = mailer_action unless mailer_action.nil?
+          h[LogField::AttachmentCount] = attachment_count unless attachment_count.nil?
+          h[LogField::ErrorClass] = error_class
+          h[LogField::Message] = message
+          h[LogField::Backtrace] = backtrace unless backtrace.nil?
+          h
+        end
+      end
+    end
+  end
+end

data/lib/log_struct/log/action_mailer.rb

@@ -8,6 +8,7 @@
 
 require_relative "action_mailer/delivery"
 require_relative "action_mailer/delivered"
+require_relative "action_mailer/error"
 
 module LogStruct
   module Log
@@ -17,12 +18,20 @@ module LogStruct
         const :to, T.nilable(T::Array[String]), default: nil
         const :from, T.nilable(String), default: nil
         const :subject, T.nilable(String), default: nil
+        const :message_id, T.nilable(String), default: nil
+        const :mailer_class, T.nilable(String), default: nil
+        const :mailer_action, T.nilable(String), default: nil
+        const :attachment_count, T.nilable(Integer), default: nil
 
         Kwargs = T.type_alias do
           {
             to: T.nilable(T::Array[String]),
             from: T.nilable(String),
-            subject: T.nilable(String)
+            subject: T.nilable(String),
+            message_id: T.nilable(String),
+            mailer_class: T.nilable(String),
+            mailer_action: T.nilable(String),
+            attachment_count: T.nilable(Integer)
           }
         end
 
@@ -31,7 +40,11 @@ module LogStruct
           {
             to: to,
             from: from,
-            subject: subject
+            subject: subject,
+            message_id: message_id,
+            mailer_class: mailer_class,
+            mailer_action: mailer_action,
+            attachment_count: attachment_count
           }
         end
       end