lapsoss 0.1.0 → 0.3.0

data/lib/lapsoss/middleware.rb

@@ -2,352 +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
-        if @sample_callback
-          return nil unless @sample_callback.call(event, hint)
-        end
-
-        # Apply rate-based sampling
-        if @sample_rate < 1.0
-          return nil if rand > @sample_rate
-        end
-
-        @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
-        if @privacy_mode
-          enhanced_user = apply_privacy_filtering(enhanced_user)
-        end
-
-        event.context[:user] = enhanced_user unless enhanced_user.empty?
-      end
-
-      def apply_privacy_filtering(user_data)
-        # Remove sensitive fields in privacy mode
-        sensitive_fields = [:email, :phone, :address, :ssn, :credit_card]
-        filtered = user_data.dup
-
-        sensitive_fields.each do |field|
-          if filtered.key?(field)
-            filtered[field] = "[FILTERED]"
-          end
-        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
-
-        if release_info
-          event.context[:release] = release_info
-        end
-      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.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["DYNO"]
-          info[:slug_commit] = ENV["HEROKU_SLUG_COMMIT"]
-        end
-
-        # Check AWS
-        if ENV["AWS_EXECUTION_ENV"]
-          info[:platform] = "aws"
-          info[:execution_env] = ENV["AWS_EXECUTION_ENV"]
-          info[:region] = ENV["AWS_REGION"]
-        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["KUBERNETES_NAMESPACE"]
-          info[:pod_name] = ENV["HOSTNAME"]
-        end
-
-        info.empty? ? nil : info
-      end
-
-      def parse_deployment_time(time_str)
-        Time.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.now
-          # Remove old events outside time window
-          @events.reject! { |timestamp| now - timestamp > @time_window }
-
-          # Check if we're over the limit
-          if @events.length >= @max_events
-            return nil
-          end
-
-          # 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
@@ -46,7 +44,7 @@ module Lapsoss
 
     def build_chain
       # The final app just returns the event
-      final_app = lambda { |event, hint| event }
+      final_app = ->(event, _hint) { event }
 
       # Build middleware chain from right to left
       @middlewares.reverse.reduce(final_app) do |app, middleware_config|
@@ -58,74 +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, *args, **kwargs)
-      @pipeline.use(middleware_class, *args, **kwargs)
-      self
-    end
-
-    def build
-      @pipeline.build
-    end
-
-    def pipeline
-      @pipeline
-    end
-  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