lapsoss 0.2.0 → 0.3.1

data/lib/lapsoss/http_client.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-require 'faraday'
-require 'faraday/retry'
-require 'json'
-require 'zlib'
+require "faraday"
+require "faraday/retry"
+require "json"
+require "zlib"
 
 module Lapsoss
   # HTTP client wrapper using Faraday with retry logic
@@ -56,7 +56,7 @@ module Lapsoss
         conn.ssl.verify = @config[:ssl_verify] if @config.key?(:ssl_verify)
 
         # Set user agent
-        conn.headers['User-Agent'] = USER_AGENT
+        conn.headers["User-Agent"] = USER_AGENT
 
         # Auto-detect and use appropriate adapter
         conn.adapter detect_optimal_adapter
@@ -78,7 +78,7 @@ module Lapsoss
     end
 
     def async_adapter_available?
-      require 'async/http/faraday'
+      require "async/http/faraday"
       true
     rescue LoadError
       false
@@ -105,8 +105,8 @@ module Lapsoss
         interval: @config[:initial_backoff] || 1.0,
         max_interval: @config[:max_backoff] || 64.0,
         backoff_factor: @config[:backoff_multiplier] || 2.0,
-        retry_statuses: [408, 429, 500, 502, 503, 504],
-        methods: [:post]
+        retry_statuses: [ 408, 429, 500, 502, 503, 504 ],
+        methods: [ :post ]
       }
     end
   end

data/lib/lapsoss/merged_scope.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Lapsoss
+  # Performance-optimized scope that provides a merged view without cloning
+  class MergedScope
+    def initialize(scope_stack, base_scope)
+      @scope_stack = scope_stack
+      @base_scope = base_scope || Scope.new
+      @own_breadcrumbs = []
+    end
+
+    def tags
+      @tags ||= merge_hash_contexts(:tags)
+    end
+
+    def user
+      @user ||= merge_hash_contexts(:user)
+    end
+
+    def extra
+      @extra ||= merge_hash_contexts(:extra)
+    end
+
+    def breadcrumbs
+      @breadcrumbs ||= merge_breadcrumbs
+    end
+
+    def add_breadcrumb(message, type: :default, **metadata)
+      breadcrumb = {
+        message: message,
+        type: type,
+        metadata: metadata,
+        timestamp: Time.now.utc
+      }
+      @own_breadcrumbs << breadcrumb
+      # Keep breadcrumbs to a reasonable limit
+      @own_breadcrumbs.shift if @own_breadcrumbs.length > 20
+      # Clear cached breadcrumbs to force recomputation
+      @breadcrumbs = nil
+    end
+
+    private
+
+    def merge_hash_contexts(key)
+      result = @base_scope.send(key).dup
+      @scope_stack.each do |context|
+        result.merge!(context[key] || {})
+      end
+      result
+    end
+
+    def merge_breadcrumbs
+      result = @base_scope.breadcrumbs.dup
+      @scope_stack.each do |context|
+        result.concat(context[:breadcrumbs]) if context[:breadcrumbs]
+      end
+      # Add our own breadcrumbs
+      result.concat(@own_breadcrumbs)
+      # Keep breadcrumbs to a reasonable limit
+      result.last(20)
+    end
+  end
+end

data/lib/lapsoss/middleware/base.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Lapsoss
+  module Middleware
+    class Base
+      def initialize(app)
+        @app = app
+      end
+
+      def call(event, hint = {})
+        @app.call(event, hint)
+      end
+    end
+  end
+end

data/lib/lapsoss/middleware/conditional_filter.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Lapsoss
+  module Middleware
+    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
+  end
+end

data/lib/lapsoss/middleware/event_enricher.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Lapsoss
+  module Middleware
+    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
+  end
+end

data/lib/lapsoss/middleware/event_transformer.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Lapsoss
+  module Middleware
+    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
+  end
+end

data/lib/lapsoss/middleware/exception_filter.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Lapsoss
+  module Middleware
+    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
+  end
+end

data/lib/lapsoss/middleware/metrics_collector.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Lapsoss
+  module Middleware
+    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
+  end
+end

data/lib/lapsoss/middleware/rate_limiter.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Lapsoss
+  module Middleware
+    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
+  end
+end

data/lib/lapsoss/middleware/release_tracker.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module Lapsoss
+  module Middleware
+    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
+  end
+end

data/lib/lapsoss/middleware/sample_filter.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Lapsoss
+  module Middleware
+    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
+  end
+end

data/lib/lapsoss/middleware/sampling_middleware.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Lapsoss
+  module Middleware
+    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/middleware/user_context_enhancer.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Lapsoss
+  module Middleware
+    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
+  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") && defined?(Redis::CannotConnectError) && 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