logstruct 0.0.1 → 0.0.2.pre.rc1

data/lib/log_struct/integrations/action_mailer/event_logging.rb

@@ -0,0 +1,90 @@
+# typed: strict
+# frozen_string_literal: true
+
+module LogStruct
+  module Integrations
+    module ActionMailer
+      # Handles logging of email delivery events
+      module EventLogging
+        extend ActiveSupport::Concern
+        extend T::Sig
+        extend T::Helpers
+        requires_ancestor { ::ActionMailer::Base }
+
+        included do
+          T.bind(self, ActionMailer::Callbacks::ClassMethods)
+
+          # Add callbacks for delivery events
+          before_deliver :log_email_delivery
+          after_deliver :log_email_delivered
+        end
+
+        protected
+
+        # Log when an email is about to be delivered
+        sig { void }
+        def log_email_delivery
+          log_mailer_event(Event::Delivery)
+        end
+
+        # Log when an email is delivered
+        sig { void }
+        def log_email_delivered
+          log_mailer_event(Event::Delivered)
+        end
+
+        private
+
+        # Log a mailer event with the given event type
+        sig do
+          params(event_type: Log::ActionMailer::ActionMailerEvent,
+            level: Symbol,
+            additional_data: T::Hash[Symbol, T.untyped]).returns(T.untyped)
+        end
+        def log_mailer_event(event_type, level = :info, additional_data = {})
+          # Get message (self refers to the mailer instance)
+          mailer_message = message if respond_to?(:message)
+
+          # Prepare data for the log entry
+          data = {
+            message_id: extract_message_id,
+            mailer_class: self.class.to_s,
+            mailer_action: action_name.to_s
+          }.compact
+
+          # Add any additional metadata
+          MetadataCollection.add_message_metadata(self, data)
+          MetadataCollection.add_context_metadata(self, data)
+          data.merge!(additional_data) if additional_data.present?
+
+          # Extract email fields (these will be filtered if email_addresses=true)
+          to = mailer_message&.to
+          from = mailer_message&.from&.first
+          subject = mailer_message&.subject
+
+          # Create a structured log entry
+          log_data = Log::ActionMailer.new(
+            event: event_type,
+            to: to,
+            from: from,
+            subject: subject,
+            additional_data: data
+          )
+          LogStruct.info(log_data)
+          log_data
+        end
+
+        # Extract message ID from the mailer
+        sig { returns(T.nilable(String)) }
+        def extract_message_id
+          return nil unless respond_to?(:message)
+
+          mail_message = message
+          return nil unless mail_message.respond_to?(:message_id)
+
+          mail_message.message_id
+        end
+      end
+    end
+  end
+end

data/lib/log_struct/integrations/action_mailer/metadata_collection.rb

@@ -0,0 +1,78 @@
+# typed: strict
+# frozen_string_literal: true
+
+module LogStruct
+  module Integrations
+    module ActionMailer
+      # Handles collection of metadata for email logging
+      module MetadataCollection
+        extend T::Sig
+        # Add message-specific metadata to log data
+        sig { params(mailer: T.untyped, log_data: T::Hash[Symbol, T.untyped]).void }
+        def self.add_message_metadata(mailer, log_data)
+          message = mailer.respond_to?(:message) ? mailer.message : nil
+
+          # Add recipient count if message is available
+          if message
+            # Don't log actual email addresses
+            log_data[:recipient_count] = [message.to, message.cc, message.bcc].flatten.compact.count
+
+            # Handle case when attachments might be nil
+            log_data[:has_attachments] = message.attachments&.any? || false
+            log_data[:attachment_count] = message.attachments&.count || 0
+          else
+            log_data[:recipient_count] = 0
+            log_data[:has_attachments] = false
+            log_data[:attachment_count] = 0
+          end
+        end
+
+        # Add context metadata to log data
+        sig { params(mailer: T.untyped, log_data: T::Hash[Symbol, T.untyped]).void }
+        def self.add_context_metadata(mailer, log_data)
+          # Add account ID information if available (but not user email)
+          extract_ids_to_log_data(mailer, log_data)
+
+          # Add any current tags from ActiveJob or ActionMailer
+          add_current_tags_to_log_data(log_data)
+        end
+
+        sig { params(mailer: T.untyped, log_data: T::Hash[Symbol, T.untyped]).void }
+        def self.extract_ids_to_log_data(mailer, log_data)
+          # Extract account ID if available
+          if mailer.instance_variable_defined?(:@account)
+            account = mailer.instance_variable_get(:@account)
+            log_data[:account_id] = account.id if account.respond_to?(:id)
+          end
+
+          # Extract user ID if available
+          return unless mailer.instance_variable_defined?(:@user)
+
+          user = mailer.instance_variable_get(:@user)
+          log_data[:user_id] = user.id if user.respond_to?(:id)
+        end
+
+        sig { params(log_data: T::Hash[Symbol, T.untyped]).void }
+        def self.add_current_tags_to_log_data(log_data)
+          # Get current tags from ActiveSupport::TaggedLogging if available
+          if ::ActiveSupport::TaggedLogging.respond_to?(:current_tags)
+            tags = T.unsafe(::ActiveSupport::TaggedLogging).current_tags
+            log_data[:tags] = tags if tags.present?
+          end
+
+          # Get request_id from ActionDispatch if available
+          if ::ActionDispatch::Request.respond_to?(:current_request_id) &&
+              T.unsafe(::ActionDispatch::Request).current_request_id.present?
+            log_data[:request_id] = T.unsafe(::ActionDispatch::Request).current_request_id
+          end
+
+          # Get job_id from ActiveJob if available
+          if defined?(::ActiveJob::Logging) && ::ActiveJob::Logging.respond_to?(:job_id) &&
+              T.unsafe(::ActiveJob::Logging).job_id.present?
+            log_data[:job_id] = T.unsafe(::ActiveJob::Logging).job_id
+          end
+        end
+      end
+    end
+  end
+end

data/lib/log_struct/integrations/action_mailer.rb

@@ -0,0 +1,50 @@
+# typed: strict
+# frozen_string_literal: true
+
+begin
+  require "action_mailer"
+rescue LoadError
+  # actionmailer gem is not available, integration will be skipped
+end
+
+if defined?(::ActionMailer)
+  require "logger"
+  require_relative "action_mailer/metadata_collection"
+  require_relative "action_mailer/event_logging"
+  require_relative "action_mailer/error_handling"
+  require_relative "action_mailer/callbacks"
+end
+
+module LogStruct
+  module Integrations
+    # ActionMailer integration for structured logging
+    module ActionMailer
+      extend T::Sig
+      extend IntegrationInterface
+
+      # Set up ActionMailer structured logging
+      sig { override.params(config: LogStruct::Configuration).returns(T.nilable(T::Boolean)) }
+      def self.setup(config)
+        return nil unless defined?(::ActionMailer)
+        return nil unless config.enabled
+        return nil unless config.integrations.enable_actionmailer
+
+        # Silence default ActionMailer logs (we use our own structured logging)
+        # This is required because we replace the logging using our own callbacks
+        if defined?(::ActionMailer::Base)
+          ::ActionMailer::Base.logger = ::Logger.new(File::NULL)
+        end
+
+        # Register our custom observers and handlers
+        # Registering these at the class level means all mailers will use them
+        ActiveSupport.on_load(:action_mailer) { prepend LogStruct::Integrations::ActionMailer::MetadataCollection }
+        ActiveSupport.on_load(:action_mailer) { prepend LogStruct::Integrations::ActionMailer::EventLogging }
+        ActiveSupport.on_load(:action_mailer) { prepend LogStruct::Integrations::ActionMailer::ErrorHandling }
+        ActiveSupport.on_load(:action_mailer) { prepend LogStruct::Integrations::ActionMailer::Callbacks }
+        ActiveSupport.on_load(:action_mailer) { LogStruct::Integrations::ActionMailer::Callbacks.patch_message_delivery }
+
+        true
+      end
+    end
+  end
+end

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

@@ -0,0 +1,104 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative "../../enums/source"
+require_relative "../../enums/event"
+require_relative "../../log/active_job"
+require_relative "../../log/error"
+
+module LogStruct
+  module Integrations
+    module ActiveJob
+      # Structured logging for ActiveJob
+      class LogSubscriber < ::ActiveJob::LogSubscriber
+        extend T::Sig
+
+        sig { params(event: T.untyped).void }
+        def enqueue(event)
+          job = event.payload[:job]
+          log_job_event(Event::Enqueue, job, event)
+        end
+
+        sig { params(event: T.untyped).void }
+        def enqueue_at(event)
+          job = event.payload[:job]
+          log_job_event(Event::Schedule, job, event, scheduled_at: job.scheduled_at)
+        end
+
+        sig { params(event: T.untyped).void }
+        def perform(event)
+          job = event.payload[:job]
+          exception = event.payload[:exception_object]
+
+          if exception
+            # Log the exception with the job context
+            log_exception(exception, job, event)
+          else
+            log_job_event(Event::Finish, job, event, duration: event.duration.round(2))
+          end
+        end
+
+        sig { params(event: T.untyped).void }
+        def perform_start(event)
+          job = event.payload[:job]
+          log_job_event(Event::Start, job, event)
+        end
+
+        private
+
+        sig { params(event_type: T.any(Event::Enqueue, Event::Schedule, Event::Start, Event::Finish), job: T.untyped, _event: T.untyped, additional_data: T::Hash[Symbol, T.untyped]).void }
+        def log_job_event(event_type, job, _event, additional_data = {})
+          # Create structured log data
+          log_data = Log::ActiveJob.new(
+            event: event_type,
+            job_id: job.job_id,
+            job_class: job.class.to_s,
+            queue_name: job.queue_name,
+            duration: additional_data[:duration],
+            # Add arguments if the job class allows it
+            arguments: job.class.log_arguments? ? job.arguments : nil,
+            # Store additional data in the data hash
+            additional_data: {
+              executions: job.executions,
+              scheduled_at: additional_data[:scheduled_at],
+              provider_job_id: job.provider_job_id
+            }.compact
+          )
+
+          # Use Rails logger with our structured formatter
+          logger.info(log_data)
+        end
+
+        sig { params(exception: StandardError, job: T.untyped, _event: T.untyped).void }
+        def log_exception(exception, job, _event)
+          # Create job context data for the exception
+          job_context = {
+            job_id: job.job_id,
+            job_class: job.class.to_s,
+            queue_name: job.queue_name,
+            executions: job.executions,
+            provider_job_id: job.provider_job_id
+          }
+
+          # Add arguments if the job class allows it
+          job_context[:arguments] = job.arguments if job.class.log_arguments?
+
+          # Create exception log with job source and context
+          log_data = Log::Error.from_exception(
+            Source::Job,
+            exception,
+            job_context
+          )
+
+          # Use Rails logger with our structured formatter
+          logger.error(log_data)
+        end
+
+        sig { returns(::ActiveSupport::Logger) }
+        def logger
+          ::ActiveJob::Base.logger
+        end
+      end
+    end
+  end
+end

data/lib/log_struct/integrations/active_job.rb

@@ -0,0 +1,38 @@
+# typed: strict
+# frozen_string_literal: true
+
+begin
+  require "active_job"
+  require "active_job/log_subscriber"
+rescue LoadError
+  # ActiveJob gem is not available, integration will be skipped
+end
+
+require_relative "active_job/log_subscriber" if defined?(::ActiveJob::LogSubscriber)
+
+module LogStruct
+  module Integrations
+    # ActiveJob integration for structured logging
+    module ActiveJob
+      extend T::Sig
+      extend IntegrationInterface
+
+      # Set up ActiveJob structured logging
+      sig { override.params(config: LogStruct::Configuration).returns(T.nilable(T::Boolean)) }
+      def self.setup(config)
+        return nil unless defined?(::ActiveJob::LogSubscriber)
+        return nil unless config.enabled
+        return nil unless config.integrations.enable_activejob
+
+        ::ActiveSupport.on_load(:active_job) do
+          # Detach the default text formatter
+          ::ActiveJob::LogSubscriber.detach_from :active_job
+
+          # Attach our structured formatter
+          Integrations::ActiveJob::LogSubscriber.attach_to :active_job
+        end
+        true
+      end
+    end
+  end
+end

data/lib/log_struct/integrations/active_record.rb

@@ -0,0 +1,258 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "active_support/notifications"
+
+module LogStruct
+  module Integrations
+    # ActiveRecord Integration for SQL Query Logging
+    #
+    # This integration captures and structures all SQL queries executed through ActiveRecord,
+    # providing detailed performance and debugging information in a structured format.
+    #
+    # ## Features:
+    # - Captures all SQL queries with execution time
+    # - Safely filters sensitive data from bind parameters
+    # - Extracts database operation metadata
+    # - Provides connection pool monitoring information
+    # - Identifies query types and table names
+    #
+    # ## Performance Considerations:
+    # - Minimal overhead on query execution
+    # - Async logging prevents I/O blocking
+    # - Configurable to disable in production if needed
+    # - Smart filtering reduces log volume for repetitive queries
+    #
+    # ## Security:
+    # - SQL queries are always parameterized (safe)
+    # - Bind parameters filtered through LogStruct's param filters
+    # - Sensitive patterns automatically scrubbed
+    #
+    # ## Configuration:
+    # ```ruby
+    # LogStruct.configure do |config|
+    #   config.integrations.enable_sql_logging = true
+    #   config.integrations.sql_slow_query_threshold = 100.0 # ms
+    #   config.integrations.sql_log_bind_params = false # disable in production
+    # end
+    # ```
+    module ActiveRecord
+      extend T::Sig
+      extend IntegrationInterface
+
+      # Set up SQL query logging integration
+      sig { override.params(config: LogStruct::Configuration).returns(T.nilable(T::Boolean)) }
+      def self.setup(config)
+        return nil unless config.integrations.enable_sql_logging
+        return nil unless defined?(::ActiveRecord::Base)
+
+        subscribe_to_sql_notifications
+        true
+      end
+
+      private_class_method
+
+      # Subscribe to ActiveRecord's sql.active_record notifications
+      sig { void }
+      def self.subscribe_to_sql_notifications
+        ::ActiveSupport::Notifications.subscribe("sql.active_record") do |name, start, finish, id, payload|
+          handle_sql_event(name, start, finish, id, payload)
+        rescue => error
+          LogStruct.handle_exception(error, source: LogStruct::Source::LogStruct)
+        end
+      end
+
+      # Process SQL notification event and create structured log
+      sig { params(name: String, start: T.untyped, finish: T.untyped, id: String, payload: T::Hash[Symbol, T.untyped]).void }
+      def self.handle_sql_event(name, start, finish, id, payload)
+        # Skip schema queries and Rails internal queries
+        return if skip_query?(payload)
+
+        duration = ((finish - start) * 1000.0).round(2)
+
+        # Skip fast queries if threshold is configured
+        config = LogStruct.config
+        if config.integrations.sql_slow_query_threshold&.positive?
+          return if duration < config.integrations.sql_slow_query_threshold
+        end
+
+        sql_log = Log::SQL.new(
+          message: format_sql_message(payload),
+          source: Source::App,
+          event: Event::Database,
+          sql: payload[:sql]&.strip || "",
+          name: payload[:name] || "SQL Query",
+          duration: duration,
+          row_count: extract_row_count(payload),
+          connection_adapter: extract_adapter_name(payload),
+          bind_params: extract_and_filter_binds(payload),
+          database_name: extract_database_name(payload),
+          connection_pool_size: extract_pool_size(payload),
+          active_connections: extract_active_connections(payload),
+          operation_type: extract_operation_type(payload),
+          table_names: extract_table_names(payload)
+        )
+
+        LogStruct.info(sql_log)
+      end
+
+      # Determine if query should be skipped from logging
+      sig { params(payload: T::Hash[Symbol, T.untyped]).returns(T::Boolean) }
+      def self.skip_query?(payload)
+        query_name = payload[:name]
+        sql = payload[:sql]
+
+        # Skip Rails schema queries
+        return true if query_name&.include?("SCHEMA")
+        return true if query_name&.include?("CACHE")
+
+        # Skip common Rails internal queries
+        return true if sql&.include?("schema_migrations")
+        return true if sql&.include?("ar_internal_metadata")
+
+        # Skip SHOW/DESCRIBE queries
+        return true if sql&.match?(/\A\s*(SHOW|DESCRIBE|EXPLAIN)\s/i)
+
+        false
+      end
+
+      # Format a readable message for the SQL log
+      sig { params(payload: T::Hash[Symbol, T.untyped]).returns(String) }
+      def self.format_sql_message(payload)
+        operation_name = payload[:name] || "SQL Query"
+        "#{operation_name} executed"
+      end
+
+      # Extract row count from payload
+      sig { params(payload: T::Hash[Symbol, T.untyped]).returns(T.nilable(Integer)) }
+      def self.extract_row_count(payload)
+        row_count = payload[:row_count]
+        row_count.is_a?(Integer) ? row_count : nil
+      end
+
+      # Extract database adapter name
+      sig { params(payload: T::Hash[Symbol, T.untyped]).returns(T.nilable(String)) }
+      def self.extract_adapter_name(payload)
+        connection = payload[:connection]
+        return nil unless connection
+
+        adapter_name = connection.class.name
+        adapter_name&.split("::")&.last
+      end
+
+      # Extract and filter bind parameters
+      sig { params(payload: T::Hash[Symbol, T.untyped]).returns(T.nilable(T::Array[T.untyped])) }
+      def self.extract_and_filter_binds(payload)
+        return nil unless LogStruct.config.integrations.sql_log_bind_params
+
+        # Prefer type_casted_binds as they're more readable
+        binds = payload[:type_casted_binds] || payload[:binds]
+        return nil unless binds
+
+        # Filter sensitive data from bind parameters
+        binds.map do |bind|
+          filter_bind_parameter(bind)
+        end
+      end
+
+      # Extract database name from connection
+      sig { params(payload: T::Hash[Symbol, T.untyped]).returns(T.nilable(String)) }
+      def self.extract_database_name(payload)
+        connection = payload[:connection]
+        return nil unless connection
+
+        if connection.respond_to?(:current_database)
+          connection.current_database
+        elsif connection.respond_to?(:database)
+          connection.database
+        end
+      rescue
+        nil
+      end
+
+      # Extract connection pool size
+      sig { params(payload: T::Hash[Symbol, T.untyped]).returns(T.nilable(Integer)) }
+      def self.extract_pool_size(payload)
+        connection = payload[:connection]
+        return nil unless connection
+
+        pool = connection.pool if connection.respond_to?(:pool)
+        pool&.size
+      rescue
+        nil
+      end
+
+      # Extract active connection count
+      sig { params(payload: T::Hash[Symbol, T.untyped]).returns(T.nilable(Integer)) }
+      def self.extract_active_connections(payload)
+        connection = payload[:connection]
+        return nil unless connection
+
+        pool = connection.pool if connection.respond_to?(:pool)
+        pool&.stat&.[](:busy)
+      rescue
+        nil
+      end
+
+      # Extract SQL operation type (SELECT, INSERT, etc.)
+      sig { params(payload: T::Hash[Symbol, T.untyped]).returns(T.nilable(String)) }
+      def self.extract_operation_type(payload)
+        sql = payload[:sql]
+        return nil unless sql
+
+        # Extract first word of SQL query
+        match = sql.strip.match(/\A\s*(\w+)/i)
+        match&.captures&.first&.upcase
+      end
+
+      # Extract table names from SQL query
+      sig { params(payload: T::Hash[Symbol, T.untyped]).returns(T.nilable(T::Array[String])) }
+      def self.extract_table_names(payload)
+        sql = payload[:sql]
+        return nil unless sql
+
+        # Simple regex to extract table names (basic implementation)
+        # This covers most common cases but could be enhanced
+        tables = []
+
+        # Match FROM, JOIN, UPDATE, INSERT INTO, DELETE FROM patterns
+        sql.scan(/(?:FROM|JOIN|UPDATE|INTO|DELETE\s+FROM)\s+["`]?(\w+)["`]?/i) do |match|
+          table_name = match[0]
+          tables << table_name unless tables.include?(table_name)
+        end
+
+        tables.empty? ? nil : tables
+      end
+
+      # Filter individual bind parameter values to remove sensitive data
+      sig { params(value: T.untyped).returns(T.untyped) }
+      def self.filter_bind_parameter(value)
+        case value
+        when String
+          # Filter strings that look like passwords, tokens, secrets, etc.
+          if looks_sensitive?(value)
+            "[FILTERED]"
+          else
+            value
+          end
+        else
+          value
+        end
+      end
+
+      # Check if a string value looks sensitive and should be filtered
+      sig { params(value: String).returns(T::Boolean) }
+      def self.looks_sensitive?(value)
+        # Filter very long strings that might be tokens
+        return true if value.length > 50
+
+        # Filter strings that look like hashed passwords, API keys, tokens
+        return true if value.match?(/\A[a-f0-9]{32,}\z/i)  # MD5, SHA, etc.
+        return true if value.match?(/\A[A-Za-z0-9+\/]{20,}={0,2}\z/)  # Base64
+        return true if value.match?(/(password|secret|token|key|auth)/i)
+
+        false
+      end
+    end
+  end
+end