logstruct 0.0.1 → 0.0.2.pre.rc1

data/lib/log_struct/integrations/integration_interface.rb

@@ -0,0 +1,21 @@
+# typed: strict
+# frozen_string_literal: true
+
+module LogStruct
+  module Integrations
+    # Interface that all integrations must implement
+    # This ensures consistent behavior across all integration modules
+    module IntegrationInterface
+      extend T::Sig
+      extend T::Helpers
+
+      # This is an interface that should be implemented by all integration modules
+      interface!
+
+      # All integrations must implement this method to set up their functionality
+      # @return [Boolean, nil] Returns true if setup was successful, nil if skipped
+      sig { abstract.params(config: LogStruct::Configuration).returns(T.nilable(T::Boolean)) }
+      def setup(config); end
+    end
+  end
+end

data/lib/log_struct/integrations/lograge.rb

@@ -0,0 +1,114 @@
+# typed: strict
+# frozen_string_literal: true
+
+begin
+  require "lograge"
+rescue LoadError
+  # Lograge gem is not available, integration will be skipped
+end
+
+module LogStruct
+  module Integrations
+    # Lograge integration for structured request logging
+    module Lograge
+      extend IntegrationInterface
+
+      class << self
+        extend T::Sig
+
+        # Set up lograge for structured request logging
+        sig { override.params(logstruct_config: LogStruct::Configuration).returns(T.nilable(T::Boolean)) }
+        def setup(logstruct_config)
+          return nil unless defined?(::Lograge)
+          return nil unless logstruct_config.enabled
+          return nil unless logstruct_config.integrations.enable_lograge
+
+          configure_lograge(logstruct_config)
+
+          true
+        end
+
+        private_class_method
+
+        sig { params(logstruct_config: LogStruct::Configuration).void }
+        def configure_lograge(logstruct_config)
+          ::Rails.application.configure do
+            config.lograge.enabled = true
+            # Use a raw formatter that just returns the log struct.
+            # The struct is converted to JSON by our Formatter (after filtering, etc.)
+            config.lograge.formatter = T.let(
+              lambda do |data|
+                # Convert the data hash to a Log::Request struct
+                Log::Request.new(
+                  source: Source::Rails,
+                  event: Event::Request,
+                  timestamp: Time.now,
+                  http_method: data[:method],
+                  path: data[:path],
+                  format: data[:format],
+                  controller: data[:controller],
+                  action: data[:action],
+                  status: data[:status],
+                  duration: data[:duration],
+                  view: data[:view],
+                  db: data[:db],
+                  params: data[:params]
+                )
+              end,
+              T.proc.params(hash: T::Hash[Symbol, T.untyped]).returns(Log::Request)
+            )
+
+            # Add custom options to lograge
+            config.lograge.custom_options = lambda do |event|
+              Integrations::Lograge.lograge_default_options(event)
+            end
+          end
+        end
+
+        sig { params(event: ActiveSupport::Notifications::Event).returns(T::Hash[Symbol, T.untyped]) }
+        def lograge_default_options(event)
+          # Extract essential fields from the payload
+          options = event.payload.slice(
+            :request_id,
+            :host,
+            :source_ip
+          ).compact
+
+          if event.payload[:params].present?
+            options[:params] = event.payload[:params].except("controller", "action")
+          end
+
+          # Process headers if available
+          process_headers(event, options)
+
+          # Apply custom options from application if provided
+          apply_custom_options(event, options)
+
+          options
+        end
+
+        # Process headers from the event payload
+        sig { params(event: ActiveSupport::Notifications::Event, options: T::Hash[Symbol, T.untyped]).void }
+        def process_headers(event, options)
+          headers = event.payload[:headers]
+          return if headers.blank?
+
+          options[:user_agent] = headers["HTTP_USER_AGENT"]
+          options[:content_type] = headers["CONTENT_TYPE"]
+          options[:accept] = headers["HTTP_ACCEPT"]
+        end
+
+        # Apply custom options from the application's configuration
+        sig { params(event: ActiveSupport::Notifications::Event, options: T::Hash[Symbol, T.untyped]).void }
+        def apply_custom_options(event, options)
+          custom_options_proc = LogStruct.config.integrations.lograge_custom_options
+          return unless custom_options_proc&.respond_to?(:call)
+
+          # Call the proc with the event and options
+          # The proc can modify the options hash directly
+          custom_options_proc.call(event, options)
+        end
+      end
+    end
+  end
+end

data/lib/log_struct/integrations/rack.rb

@@ -0,0 +1,31 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "rack"
+require "action_dispatch/middleware/show_exceptions"
+require_relative "rack/error_handling_middleware"
+
+module LogStruct
+  module Integrations
+    # Rack middleware integration for structured logging
+    module Rack
+      extend T::Sig
+      extend IntegrationInterface
+
+      # 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
+
+        # Add structured logging middleware for security violations and errors
+        # Need to insert after ShowExceptions to catch IP spoofing errors
+        ::Rails.application.middleware.insert_after(
+          ::ActionDispatch::ShowExceptions,
+          Integrations::RackErrorHandler::Middleware
+        )
+        true
+      end
+    end
+  end
+end

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

@@ -0,0 +1,146 @@
+# typed: strict
+# frozen_string_literal: true
+
+module LogStruct
+  module Integrations
+    module RackErrorHandler
+      # Custom middleware to enhance Rails error logging with JSON format and request details
+      class Middleware
+        extend T::Sig
+
+        # IP Spoofing error response
+        IP_SPOOF_HTML = T.let(
+          "<html><head><title>IP Spoofing Detected</title></head><body>" \
+          "<h1>Forbidden</h1>" \
+          "<p>IP spoofing detected. This request has been blocked for security reasons.</p>" \
+          "</body></html>",
+          String
+        )
+
+        # CSRF error response
+        CSRF_HTML = T.let(
+          "<html><head><title>CSRF Error</title></head><body>" \
+          "<h1>Forbidden</h1>" \
+          "<p>Invalid authenticity token. This request has been blocked to prevent cross-site request forgery.</p>" \
+          "</body></html>",
+          String
+        )
+
+        # Response headers calculated at load time
+        IP_SPOOF_HEADERS = T.let(
+          {
+            "Content-Type" => "text/html",
+            "Content-Length" => IP_SPOOF_HTML.bytesize.to_s
+          }.freeze,
+          T::Hash[String, String]
+        )
+
+        CSRF_HEADERS = T.let(
+          {
+            "Content-Type" => "text/html",
+            "Content-Length" => CSRF_HTML.bytesize.to_s
+          }.freeze,
+          T::Hash[String, String]
+        )
+
+        # HTTP status code for forbidden responses
+        FORBIDDEN_STATUS = T.let(403, Integer)
+
+        sig { params(app: T.untyped).void }
+        def initialize(app)
+          @app = app
+        end
+
+        sig { params(env: T.untyped).returns(T.untyped) }
+        def call(env)
+          return @app.call(env) unless LogStruct.enabled?
+
+          # Try to process the request
+          begin
+            @app.call(env)
+          rescue ::ActionDispatch::RemoteIp::IpSpoofAttackError => ip_spoof_error
+            # Create a security log for IP spoofing
+            security_log = Log::Security.new(
+              event: Event::IPSpoof,
+              message: ip_spoof_error.message,
+              # Can't call .remote_ip on the request because that's what raises the error.
+              # Have to pass the client_ip and x_forwarded_for headers.
+              client_ip: env["HTTP_CLIENT_IP"],
+              x_forwarded_for: env["HTTP_X_FORWARDED_FOR"],
+              path: env["PATH_INFO"],
+              http_method: env["REQUEST_METHOD"],
+              user_agent: env["HTTP_USER_AGENT"],
+              referer: env["HTTP_REFERER"],
+              request_id: env["action_dispatch.request_id"]
+            )
+
+            # Log the structured data
+            ::Rails.logger.warn(security_log)
+
+            # Report the error
+            context = extract_request_context(env)
+            LogStruct.handle_exception(ip_spoof_error, source: Source::Security, context: context)
+
+            # If handle_exception raised an exception then Rails will deal with it (e.g. config.exceptions_app)
+            # If we are only logging or reporting these security errors, then return a default response
+            [FORBIDDEN_STATUS, IP_SPOOF_HEADERS, [IP_SPOOF_HTML]]
+          rescue ::ActionController::InvalidAuthenticityToken => invalid_auth_token_error
+            # Create a security log for CSRF error
+            request = ::ActionDispatch::Request.new(env)
+            security_log = Log::Security.new(
+              event: Event::CSRFViolation,
+              message: invalid_auth_token_error.message,
+              path: request.path,
+              http_method: request.method,
+              source_ip: request.remote_ip,
+              user_agent: request.user_agent,
+              referer: request.referer,
+              request_id: request.request_id
+            )
+            LogStruct.error(security_log)
+
+            # Report to error reporting service and/or re-raise
+            context = extract_request_context(env)
+            LogStruct.handle_exception(invalid_auth_token_error, source: Source::Security, context: context)
+
+            # If handle_exception raised an exception then Rails will deal with it (e.g. config.exceptions_app)
+            # If we are only logging or reporting these security errors, then return a default response
+            [FORBIDDEN_STATUS, CSRF_HEADERS, [CSRF_HTML]]
+          rescue => error
+            # Extract request context for error reporting
+            context = extract_request_context(env)
+
+            # Create and log a structured exception with request context
+            exception_log = Log::Error.from_exception(
+              Source::Rails,
+              error,
+              context
+            )
+            LogStruct.error(exception_log)
+
+            # Re-raise any standard errors to let Rails or error reporter handle it.
+            # Rails will also log the request details separately
+            raise error
+          end
+        end
+
+        private
+
+        sig { params(env: T::Hash[String, T.untyped]).returns(T::Hash[Symbol, T.untyped]) }
+        def extract_request_context(env)
+          request = ::ActionDispatch::Request.new(env)
+          {
+            request_id: request.request_id,
+            path: request.path,
+            method: request.method,
+            user_agent: request.user_agent,
+            referer: request.referer
+          }
+        rescue => error
+          # If we can't extract request context, return minimal info
+          {error_extracting_context: error.message}
+        end
+      end
+    end
+  end
+end

data/lib/log_struct/integrations/rack_error_handler.rb

@@ -0,0 +1,32 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "rack"
+require "action_dispatch/middleware/show_exceptions"
+require_relative "rack_error_handler/middleware"
+
+module LogStruct
+  module Integrations
+    # Rack middleware integration for structured logging
+    module RackErrorHandler
+      extend T::Sig
+      extend IntegrationInterface
+
+      # 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
+
+        # Add structured logging middleware for security violations and errors
+        # Need to insert after ShowExceptions to catch IP spoofing errors
+        ::Rails.application.middleware.insert_after(
+          ::ActionDispatch::ShowExceptions,
+          Integrations::RackErrorHandler::Middleware
+        )
+
+        true
+      end
+    end
+  end
+end

data/lib/log_struct/integrations/shrine.rb

@@ -0,0 +1,75 @@
+# typed: strict
+# frozen_string_literal: true
+
+begin
+  require "shrine"
+rescue LoadError
+  # Shrine gem is not available, integration will be skipped
+end
+
+module LogStruct
+  module Integrations
+    # Shrine integration for structured logging
+    module Shrine
+      extend T::Sig
+      extend IntegrationInterface
+
+      # Set up Shrine structured logging
+      sig { override.params(config: LogStruct::Configuration).returns(T.nilable(T::Boolean)) }
+      def self.setup(config)
+        return nil unless defined?(::Shrine)
+        return nil unless config.enabled
+        return nil unless config.integrations.enable_shrine
+
+        # Create a structured log subscriber for Shrine
+        # ActiveSupport::Notifications::Event has name, time, end, transaction_id, payload, and duration
+        shrine_log_subscriber = T.unsafe(lambda do |event|
+          payload = event.payload.except(:io, :metadata, :name).dup
+
+          # Map event name to Event type
+          event_type = case event.name
+          when :upload then Event::Upload
+          when :download then Event::Download
+          when :delete then Event::Delete
+          when :metadata then Event::Metadata
+          when :exists then Event::Exist # ActiveStorage uses 'exist', may as well use that
+          else Event::Unknown
+          end
+
+          # Create structured log data
+          log_data = Log::Shrine.new(
+            source: Source::Shrine,
+            event: event_type,
+            duration: event.duration,
+            storage: payload[:storage],
+            location: payload[:location],
+            uploader: payload[:uploader],
+            upload_options: payload[:upload_options],
+            download_options: payload[:download_options],
+            options: payload[:options],
+            # Data is flattened by the JSON formatter
+            additional_data: payload.except(
+              :storage,
+              :location,
+              :uploader,
+              :upload_options,
+              :download_options,
+              :options
+            )
+          )
+
+          # Pass the structured hash to the logger
+          # If Rails.logger has our Formatter, it will handle JSON conversion
+          ::Shrine.logger.info log_data
+        end)
+
+        # Configure Shrine to use our structured log subscriber
+        ::Shrine.plugin :instrumentation,
+          events: %i[upload exists download delete],
+          log_subscriber: shrine_log_subscriber
+
+        true
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative "../../semantic_logger/logger"
+require_relative "../../log/sidekiq"
+require_relative "../../enums/source"
+
+module LogStruct
+  module Integrations
+    module Sidekiq
+      extend T::Sig
+
+      # Get thread ID for Sidekiq logging
+      sig { returns(String) }
+      def self.tid
+        Thread.current["sidekiq_tid"] ||= (Thread.current.object_id ^ ::Process.pid).to_s(36)
+      end
+
+      # Custom Logger for Sidekiq that creates LogStruct::Log::Sidekiq entries
+      class Logger < LogStruct::SemanticLogger::Logger
+        extend T::Sig
+
+        # 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|
+            # 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 : ""),
+              process_id: ::Process.pid,
+              thread_id: Sidekiq.tid,
+              context: ::Sidekiq::Context.current || {}
+            )
+
+            # Pass the struct to SemanticLogger
+            super(log_struct, payload, &nil)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/log_struct/integrations/sidekiq.rb

@@ -0,0 +1,39 @@
+# typed: strict
+# frozen_string_literal: true
+
+begin
+  require "sidekiq"
+rescue LoadError
+  # Sidekiq gem is not available, integration will be skipped
+end
+require_relative "sidekiq/logger" if defined?(::Sidekiq)
+
+module LogStruct
+  module Integrations
+    # Sidekiq integration for structured logging
+    module Sidekiq
+      extend T::Sig
+      extend IntegrationInterface
+
+      # Set up Sidekiq structured logging
+      sig { override.params(config: LogStruct::Configuration).returns(T.nilable(T::Boolean)) }
+      def self.setup(config)
+        return nil unless defined?(::Sidekiq)
+        return nil unless config.enabled
+        return nil unless config.integrations.enable_sidekiq
+
+        # Configure Sidekiq server (worker) to use our logger
+        ::Sidekiq.configure_server do |sidekiq_config|
+          sidekiq_config.logger = LogStruct::Integrations::Sidekiq::Logger.new("Sidekiq-Server")
+        end
+
+        # Configure Sidekiq client (Rails app) to use our logger
+        ::Sidekiq.configure_client do |sidekiq_config|
+          sidekiq_config.logger = LogStruct::Integrations::Sidekiq::Logger.new("Sidekiq-Client")
+        end
+
+        true
+      end
+    end
+  end
+end

data/lib/log_struct/integrations/sorbet.rb

@@ -0,0 +1,49 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+
+module LogStruct
+  module Integrations
+    # Integration for Sorbet runtime type checking error handlers
+    # This module installs error handlers that report type errors through LogStruct
+    # These handlers can be enabled/disabled using configuration
+    module Sorbet
+      extend T::Sig
+      extend IntegrationInterface
+
+      # Set up Sorbet error handlers to report errors through LogStruct
+      sig { override.params(config: LogStruct::Configuration).returns(T.nilable(T::Boolean)) }
+      def self.setup(config)
+        return nil unless config.integrations.enable_sorbet_error_handlers
+
+        # Install inline type error handler
+        # Called when T.let, T.cast, T.must, etc. fail
+        T::Configuration.inline_type_error_handler = lambda do |error, _opts|
+          LogStruct.handle_exception(error, source: LogStruct::Source::TypeChecking)
+        end
+
+        # Install call validation error handler
+        # Called when method signature validation fails
+        T::Configuration.call_validation_error_handler = lambda do |_signature, opts|
+          error = TypeError.new(opts[:pretty_message])
+          LogStruct.handle_exception(error, source: LogStruct::Source::TypeChecking)
+        end
+
+        # Install sig builder error handler
+        # Called when there's a problem with a signature definition
+        T::Configuration.sig_builder_error_handler = lambda do |error, _location|
+          LogStruct.handle_exception(error, source: LogStruct::Source::TypeChecking)
+        end
+
+        # Install sig validation error handler
+        # Called when there's a problem with a signature validation
+        T::Configuration.sig_validation_error_handler = lambda do |error, _opts|
+          LogStruct.handle_exception(error, source: LogStruct::Source::TypeChecking)
+        end
+
+        true
+      end
+    end
+  end
+end

data/lib/log_struct/integrations.rb

@@ -0,0 +1,41 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative "integrations/integration_interface"
+require_relative "integrations/active_job"
+require_relative "integrations/active_record"
+require_relative "integrations/rack_error_handler"
+require_relative "integrations/host_authorization"
+require_relative "integrations/action_mailer"
+require_relative "integrations/lograge"
+require_relative "integrations/shrine"
+require_relative "integrations/sidekiq"
+require_relative "integrations/good_job"
+require_relative "integrations/active_storage"
+require_relative "integrations/carrierwave"
+require_relative "integrations/sorbet"
+
+module LogStruct
+  module Integrations
+    extend T::Sig
+
+    sig { void }
+    def self.setup_integrations
+      config = LogStruct.config
+
+      # Set up each integration with consistent configuration pattern
+      Integrations::Lograge.setup(config) if config.integrations.enable_lograge
+      Integrations::ActionMailer.setup(config) if config.integrations.enable_actionmailer
+      Integrations::ActiveJob.setup(config) if config.integrations.enable_activejob
+      Integrations::ActiveRecord.setup(config) if config.integrations.enable_sql_logging
+      Integrations::Sidekiq.setup(config) if config.integrations.enable_sidekiq
+      Integrations::GoodJob.setup(config) if config.integrations.enable_goodjob
+      Integrations::HostAuthorization.setup(config) if config.integrations.enable_host_authorization
+      Integrations::RackErrorHandler.setup(config) if config.integrations.enable_rack_error_handler
+      Integrations::Shrine.setup(config) if config.integrations.enable_shrine
+      Integrations::ActiveStorage.setup(config) if config.integrations.enable_activestorage
+      Integrations::CarrierWave.setup(config) if config.integrations.enable_carrierwave
+      Integrations::Sorbet.setup(config) if config.integrations.enable_sorbet_error_handlers
+    end
+  end
+end

data/lib/log_struct/log/action_mailer.rb

@@ -0,0 +1,55 @@
+# 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
+    # Email log entry for structured logging
+    class ActionMailer < T::Struct
+      extend T::Sig
+
+      include Interfaces::CommonFields
+      include Interfaces::AdditionalDataField
+      include SerializeCommon
+      include MergeAdditionalDataFields
+
+      ActionMailerEvent = T.type_alias {
+        T.any(Event::Delivery, Event::Delivered)
+      }
+
+      # Common fields
+      const :source, Source::Mailer, default: T.let(Source::Mailer, Source::Mailer)
+      const :event, ActionMailerEvent
+      const :timestamp, Time, factory: -> { Time.now }
+      const :level, Level, default: T.let(Level::Info, Level)
+
+      # Email-specific fields
+      const :to, T.nilable(T.any(String, T::Array[String])), default: nil
+      const :from, T.nilable(String), default: nil
+      const :subject, T.nilable(String), 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 email-specific fields if they're present
+        hash[LOG_KEYS.fetch(:to)] = to if to
+        hash[LOG_KEYS.fetch(:from)] = from if from
+        hash[LOG_KEYS.fetch(:subject)] = subject if subject
+
+        hash
+      end
+    end
+  end
+end