lapsoss 0.2.0 → 0.3.0

data/lib/lapsoss/middleware.rb

@@ -2,344 +2,5 @@
 
 module Lapsoss
   module Middleware
-    class Base
-      def initialize(app)
-        @app = app
-      end
-
-      def call(event, hint = {})
-        @app.call(event, hint)
-      end
-    end
-
-    # Built-in middleware for common functionality
-    class SampleFilter < Base
-      def initialize(app, sample_rate: 1.0, sample_callback: nil)
-        super(app)
-        @sample_rate = sample_rate
-        @sample_callback = sample_callback
-      end
-
-      def call(event, hint = {})
-        # Apply custom sampling logic first
-        return nil if @sample_callback && !@sample_callback.call(event, hint)
-
-        # Apply rate-based sampling
-        return nil if (@sample_rate < 1.0) && (rand > @sample_rate)
-
-        @app.call(event, hint)
-      end
-    end
-
-    class ExceptionFilter < Base
-      def initialize(app, excluded_exceptions: [], excluded_patterns: [])
-        super(app)
-        @excluded_exceptions = Array(excluded_exceptions)
-        @excluded_patterns = Array(excluded_patterns)
-      end
-
-      def call(event, hint = {})
-        return nil if should_exclude?(event)
-
-        @app.call(event, hint)
-      end
-
-      private
-
-      def should_exclude?(event)
-        return false unless event.exception
-
-        exception_class = event.exception.class
-        exception_message = event.exception.message
-
-        # Check exact class matches
-        return true if @excluded_exceptions.any? { |klass| exception_class <= klass }
-
-        # Check pattern matches
-        @excluded_patterns.any? do |pattern|
-          case pattern
-          when Regexp
-            exception_message&.match?(pattern) || exception_class.name.match?(pattern)
-          when String
-            exception_message&.include?(pattern) || exception_class.name.include?(pattern)
-          else
-            false
-          end
-        end
-      end
-    end
-
-    class UserContextEnhancer < Base
-      def initialize(app, user_provider: nil, privacy_mode: false)
-        super(app)
-        @user_provider = user_provider
-        @privacy_mode = privacy_mode
-      end
-
-      def call(event, hint = {})
-        enhance_user_context(event, hint)
-        @app.call(event, hint)
-      end
-
-      private
-
-      def enhance_user_context(event, hint)
-        # Get user from provider if available
-        user_data = @user_provider&.call(event, hint) || {}
-
-        # Merge with existing user context
-        existing_user = event.context[:user] || {}
-        enhanced_user = existing_user.merge(user_data)
-
-        # Apply privacy filtering if enabled
-        enhanced_user = apply_privacy_filtering(enhanced_user) if @privacy_mode
-
-        event.context[:user] = enhanced_user unless enhanced_user.empty?
-      end
-
-      def apply_privacy_filtering(user_data)
-        # Remove sensitive fields in privacy mode
-        sensitive_fields = %i[email phone address ssn credit_card]
-        filtered = user_data.dup
-
-        sensitive_fields.each do |field|
-          filtered[field] = '[FILTERED]' if filtered.key?(field)
-        end
-
-        filtered
-      end
-    end
-
-    class ReleaseTracker < Base
-      def initialize(app, release_provider: nil)
-        super(app)
-        @release_provider = release_provider
-      end
-
-      def call(event, hint = {})
-        add_release_info(event, hint)
-        @app.call(event, hint)
-      end
-
-      private
-
-      def add_release_info(event, hint)
-        release_info = @release_provider&.call(event, hint) || auto_detect_release
-
-        event.context[:release] = release_info if release_info
-      end
-
-      def auto_detect_release
-        release_info = {}
-
-        # Try to detect Git information
-        if git_info = detect_git_info
-          release_info.merge!(git_info)
-        end
-
-        # Try to detect deployment info
-        if deployment_info = detect_deployment_info
-          release_info.merge!(deployment_info)
-        end
-
-        release_info.empty? ? nil : release_info
-      end
-
-      def detect_git_info
-        return nil unless File.exist?('.git')
-
-        begin
-          # Get current commit SHA
-          commit_sha = `git rev-parse HEAD`.strip
-          return nil if commit_sha.empty?
-
-          # Get branch name
-          branch = `git rev-parse --abbrev-ref HEAD`.strip
-          branch = nil if branch.empty? || branch == 'HEAD'
-
-          # Get commit timestamp
-          commit_time = `git log -1 --format=%ct`.strip
-          commit_timestamp = commit_time.empty? ? nil : Time.zone.at(commit_time.to_i)
-
-          # Get tag if on a tag
-          tag = `git describe --exact-match --tags HEAD 2>/dev/null`.strip
-          tag = nil if tag.empty?
-
-          {
-            commit_sha: commit_sha,
-            branch: branch,
-            tag: tag,
-            commit_timestamp: commit_timestamp
-          }.compact
-        rescue StandardError
-          nil
-        end
-      end
-
-      def detect_deployment_info
-        info = {}
-
-        # Check common deployment environment variables
-        info[:deployment_id] = ENV['DEPLOYMENT_ID'] if ENV['DEPLOYMENT_ID']
-        info[:build_number] = ENV['BUILD_NUMBER'] if ENV['BUILD_NUMBER']
-        info[:deployment_time] = parse_deployment_time(ENV['DEPLOYMENT_TIME']) if ENV['DEPLOYMENT_TIME']
-
-        # Check Heroku
-        if ENV['HEROKU_APP_NAME']
-          info[:platform] = 'heroku'
-          info[:app_name] = ENV['HEROKU_APP_NAME']
-          info[:dyno] = ENV.fetch('DYNO', nil)
-          info[:slug_commit] = ENV.fetch('HEROKU_SLUG_COMMIT', nil)
-        end
-
-        # Check AWS
-        if ENV['AWS_EXECUTION_ENV']
-          info[:platform] = 'aws'
-          info[:execution_env] = ENV['AWS_EXECUTION_ENV']
-          info[:region] = ENV.fetch('AWS_REGION', nil)
-        end
-
-        # Check Docker
-        if ENV['DOCKER_CONTAINER_ID'] || File.exist?('/.dockerenv')
-          info[:platform] = 'docker'
-          info[:container_id] = ENV['DOCKER_CONTAINER_ID']
-        end
-
-        # Check Kubernetes
-        if ENV['KUBERNETES_SERVICE_HOST']
-          info[:platform] = 'kubernetes'
-          info[:namespace] = ENV.fetch('KUBERNETES_NAMESPACE', nil)
-          info[:pod_name] = ENV.fetch('HOSTNAME', nil)
-        end
-
-        info.empty? ? nil : info
-      end
-
-      def parse_deployment_time(time_str)
-        Time.zone.parse(time_str)
-      rescue StandardError
-        nil
-      end
-    end
-
-    class EventEnricher < Base
-      def initialize(app, enrichers: [])
-        super(app)
-        @enrichers = enrichers
-      end
-
-      def call(event, hint = {})
-        @enrichers.each do |enricher|
-          enricher.call(event, hint)
-        end
-        @app.call(event, hint)
-      end
-    end
-
-    class ConditionalFilter < Base
-      def initialize(app, condition)
-        super(app)
-        @condition = condition
-      end
-
-      def call(event, hint = {})
-        return nil unless @condition.call(event, hint)
-
-        @app.call(event, hint)
-      end
-    end
-
-    class EventTransformer < Base
-      def initialize(app, transformer)
-        super(app)
-        @transformer = transformer
-      end
-
-      def call(event, hint = {})
-        transformed_event = @transformer.call(event, hint)
-        return nil unless transformed_event
-
-        @app.call(transformed_event, hint)
-      end
-    end
-
-    class RateLimiter < Base
-      def initialize(app, max_events: 100, time_window: 60)
-        super(app)
-        @max_events = max_events
-        @time_window = time_window
-        @events = []
-        @mutex = Mutex.new
-      end
-
-      def call(event, hint = {})
-        @mutex.synchronize do
-          now = Time.zone.now
-          # Remove old events outside time window
-          @events.reject! { |timestamp| now - timestamp > @time_window }
-
-          # Check if we're over the limit
-          return nil if @events.length >= @max_events
-
-          # Add current event
-          @events << now
-        end
-
-        @app.call(event, hint)
-      end
-    end
-
-    class MetricsCollector < Base
-      def initialize(app, collector: nil)
-        super(app)
-        @collector = collector
-        @metrics = {
-          events_processed: 0,
-          events_dropped: 0,
-          events_by_type: Hash.new(0),
-          events_by_level: Hash.new(0)
-        }
-        @mutex = Mutex.new
-      end
-
-      def call(event, hint = {})
-        @mutex.synchronize do
-          @metrics[:events_processed] += 1
-          @metrics[:events_by_type][event.type] += 1
-          @metrics[:events_by_level][event.level] += 1
-        end
-
-        result = @app.call(event, hint)
-
-        if result.nil?
-          @mutex.synchronize do
-            @metrics[:events_dropped] += 1
-          end
-        end
-
-        # Send to external collector if provided
-        @collector&.call(@metrics.dup, event, hint)
-
-        result
-      end
-
-      def metrics
-        @mutex.synchronize { @metrics.dup }
-      end
-    end
-
-    # Middleware wrapper for sampling strategies
-    class SamplingMiddleware < Base
-      def initialize(app, sampler)
-        super(app)
-        @sampler = sampler
-      end
-
-      def call(event, hint = {})
-        return nil unless @sampler.sample?(event, hint)
-
-        @app.call(event, hint)
-      end
-    end
   end
 end

data/lib/lapsoss/pipeline.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative 'middleware'
-
 module Lapsoss
   class Pipeline
     def initialize
@@ -58,70 +56,4 @@ module Lapsoss
       end
     end
   end
-
-  class PipelineBuilder
-    def initialize
-      @pipeline = Pipeline.new
-    end
-
-    def sample(rate: 1.0, &block)
-      @pipeline.use(Middleware::SampleFilter, sample_rate: rate, sample_callback: block)
-      self
-    end
-
-    def exclude_exceptions(*exception_classes, patterns: [])
-      @pipeline.use(Middleware::ExceptionFilter,
-                    excluded_exceptions: exception_classes,
-                    excluded_patterns: patterns)
-      self
-    end
-
-    def enhance_user_context(provider: nil, privacy_mode: false)
-      @pipeline.use(Middleware::UserContextEnhancer,
-                    user_provider: provider,
-                    privacy_mode: privacy_mode)
-      self
-    end
-
-    def track_releases(provider: nil)
-      @pipeline.use(Middleware::ReleaseTracker, release_provider: provider)
-      self
-    end
-
-    def rate_limit(max_events: 100, time_window: 60)
-      @pipeline.use(Middleware::RateLimiter,
-                    max_events: max_events,
-                    time_window: time_window)
-      self
-    end
-
-    def collect_metrics(collector: nil)
-      @pipeline.use(Middleware::MetricsCollector, collector: collector)
-      self
-    end
-
-    def enrich_events(*enrichers)
-      @pipeline.use(Middleware::EventEnricher, enrichers: enrichers)
-      self
-    end
-
-    def filter_if(&condition)
-      @pipeline.use(Middleware::ConditionalFilter, condition)
-      self
-    end
-
-    def transform_events(&transformer)
-      @pipeline.use(Middleware::EventTransformer, transformer)
-      self
-    end
-
-    def use_middleware(middleware_class, *, **)
-      @pipeline.use(middleware_class, *, **)
-      self
-    end
-
-    delegate :build, to: :@pipeline
-
-    attr_reader :pipeline
-  end
 end

data/lib/lapsoss/pipeline_builder.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Lapsoss
+  class PipelineBuilder
+    def initialize
+      @pipeline = Pipeline.new
+    end
+
+    def sample(rate: 1.0, &block)
+      @pipeline.use(Middleware::SampleFilter, sample_rate: rate, sample_callback: block)
+      self
+    end
+
+    def exclude_exceptions(*exception_classes, patterns: [])
+      @pipeline.use(Middleware::ExceptionFilter,
+                    excluded_exceptions: exception_classes,
+                    excluded_patterns: patterns)
+      self
+    end
+
+    def enhance_user_context(provider: nil, privacy_mode: false)
+      @pipeline.use(Middleware::UserContextEnhancer,
+                    user_provider: provider,
+                    privacy_mode: privacy_mode)
+      self
+    end
+
+    def track_releases(provider: nil)
+      @pipeline.use(Middleware::ReleaseTracker, release_provider: provider)
+      self
+    end
+
+    def rate_limit(max_events: 100, time_window: 60)
+      @pipeline.use(Middleware::RateLimiter,
+                    max_events: max_events,
+                    time_window: time_window)
+      self
+    end
+
+    def collect_metrics(collector: nil)
+      @pipeline.use(Middleware::MetricsCollector, collector: collector)
+      self
+    end
+
+    def enrich_events(*enrichers)
+      @pipeline.use(Middleware::EventEnricher, enrichers: enrichers)
+      self
+    end
+
+    def filter_if(&condition)
+      @pipeline.use(Middleware::ConditionalFilter, condition)
+      self
+    end
+
+    def transform_events(&transformer)
+      @pipeline.use(Middleware::EventTransformer, transformer)
+      self
+    end
+
+    def use_middleware(middleware_class, *, **)
+      @pipeline.use(middleware_class, *, **)
+      self
+    end
+
+    delegate :build, to: :@pipeline
+
+    attr_reader :pipeline
+  end
+end

data/lib/lapsoss/rails_error_subscriber.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Lapsoss
+  class RailsErrorSubscriber
+    def report(error, handled:, severity:, context:, source: nil)
+      # Skip certain framework errors
+      return if skip_error?(error, source)
+
+      level = map_severity(severity)
+
+      Lapsoss.capture_exception(
+        error,
+        level: level,
+        tags: {
+          handled: handled,
+          source: source || "rails"
+        },
+        context: context
+      )
+    end
+
+    private
+
+    def skip_error?(error, source)
+      # Skip cache-related Redis errors if configured to do so
+      if Lapsoss.configuration.skip_rails_cache_errors && source&.include?("cache") && error.is_a?(Redis::CannotConnectError)
+        return true
+      end
+
+      false
+    end
+
+    def map_severity(severity)
+      case severity
+      when :error then :error
+      when :warning then :warning
+      when :info then :info
+      else :error
+      end
+    end
+  end
+end

data/lib/lapsoss/rails_middleware.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Lapsoss
+  class RailsMiddleware
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      Lapsoss::Current.with_clean_scope do
+        # Add request context to current scope
+        if Lapsoss.configuration.capture_request_context
+          Rails.logger.debug "[Lapsoss] Adding request context" if Rails.env.test?
+          add_request_context(env)
+        end
+
+        begin
+          @app.call(env)
+        rescue Exception => e
+          Rails.logger.debug { "[Lapsoss] Capturing exception: #{e.class} - #{e.message}" } if Rails.env.test?
+          # Capture the exception
+          Lapsoss.capture_exception(e)
+          # Re-raise the exception to maintain Rails error handling
+          raise
+        end
+      end
+    end
+
+    private
+
+    def add_request_context(env)
+      request = Rack::Request.new(env)
+
+      return unless Lapsoss::Current.scope
+
+      Lapsoss::Current.scope.set_context("request", {
+                                           method: request.request_method,
+                                           url: request.url,
+                                           path: request.path,
+                                           query_string: request.query_string,
+                                           headers: extract_headers(env),
+                                           ip: request.ip,
+                                           user_agent: request.user_agent,
+                                           referer: request.referer,
+                                           request_id: env["action_dispatch.request_id"] || env["HTTP_X_REQUEST_ID"]
+                                         })
+
+      # Add user context if available
+      return unless env["warden"]&.user
+
+      user = env["warden"].user
+      Lapsoss::Current.scope.set_user(
+        id: user.id,
+        email: user.respond_to?(:email) ? user.email : nil
+      )
+    end
+
+    def extract_headers(env)
+      headers = {}
+
+      env.each do |key, value|
+        if key.start_with?("HTTP_") && FILTERED_HEADERS.exclude?(key)
+          header_name = key.sub(/^HTTP_/, "").split("_").map(&:capitalize).join("-")
+          headers[header_name] = value
+        end
+      end
+
+      headers
+    end
+
+    FILTERED_HEADERS = %w[
+      HTTP_AUTHORIZATION
+      HTTP_COOKIE
+      HTTP_X_API_KEY
+      HTTP_X_AUTH_TOKEN
+    ].freeze
+  end
+end

data/lib/lapsoss/railtie.rb

@@ -2,71 +2,43 @@
 
 module Lapsoss
   class Railtie < Rails::Railtie
+    Rails.logger.debug "[Lapsoss] Railtie loaded" if ENV["DEBUG_LAPSOSS"]
     config.lapsoss = ActiveSupport::OrderedOptions.new
 
-    initializer 'lapsoss.configure' do |_app|
+    initializer "lapsoss.configure" do |_app|
       Lapsoss.configure do |config|
-        config.environment ||= Rails.env
+        # Use rails_app_version gem if available, otherwise fallback to Rails defaults
+        config.environment ||= if Rails.application.respond_to?(:env)
+                                 Rails.application.env
+        else
+                                 Rails.env
+        end
+
         config.logger ||= Rails.logger
-        config.release ||= Rails.application.config.try(:release)
+
+        config.release ||= if Rails.application.respond_to?(:version)
+                             Rails.application.version.to_s
+        else
+                             Rails.application.config.try(:release)
+        end
 
         # Set default tags
         config.default_tags = {
-          rails_env: Rails.env,
+          rails_env: config.environment,
           rails_version: Rails.version
         }
       end
     end
 
-    initializer 'lapsoss.add_middleware', after: 'lapsoss.configure' do |app|
-      app.middleware.insert_before ActionDispatch::ShowExceptions, Lapsoss::Middleware
-    end
-
-    initializer 'lapsoss.rails_error_subscriber', after: 'lapsoss.add_middleware' do |app|
-      app.executor.error_reporter.subscribe(Lapsoss::RailsErrorSubscriber.new)
-    end
-
-    rake_tasks do
-      # Add any Lapsoss-specific rake tasks here
-    end
-  end
-
-  class RailsErrorSubscriber
-    def report(error, handled:, severity:, context:, source: nil)
-      # Skip certain framework errors
-      return if skip_error?(error, source)
-
-      level = map_severity(severity)
+    initializer "lapsoss.add_middleware" do |app|
+      require "lapsoss/rails_middleware"
 
-      Lapsoss.capture_exception(
-        error,
-        level: level,
-        tags: {
-          handled: handled,
-          source: source || 'rails'
-        },
-        context: context
-      )
+      # Use config.middleware to ensure it's added during initialization
+      app.config.middleware.use Lapsoss::RailsMiddleware
     end
 
-    private
-
-    def skip_error?(error, source)
-      # Skip cache-related Redis errors if configured to do so
-      if Lapsoss.configuration.skip_rails_cache_errors && source&.include?('cache') && error.is_a?(Redis::CannotConnectError)
-        return true
-      end
-
-      false
-    end
-
-    def map_severity(severity)
-      case severity
-      when :error then :error
-      when :warning then :warning
-      when :info then :info
-      else :error
-      end
+    initializer "lapsoss.rails_error_subscriber", after: "lapsoss.add_middleware" do |app|
+      app.executor.error_reporter.subscribe(Lapsoss::RailsErrorSubscriber.new)
     end
   end
 end