lapsoss 0.1.0 → 0.3.0

data/lib/lapsoss/fingerprinter.rb

@@ -51,7 +51,7 @@ module Lapsoss
 
       # File system patterns
       {
-        pattern: /Errno::(ENOENT|EACCES).*\/tmp\//,
+        pattern: %r{Errno::(ENOENT|EACCES).*/tmp/},
         fingerprint: "tmp-file-error"
       },
       {
@@ -121,9 +121,7 @@ module Lapsoss
       parts << event.message if event.message
 
       # Include first few backtrace lines for context
-      if event.exception&.backtrace
-        parts.concat(event.exception.backtrace.first(3))
-      end
+      parts.concat(event.exception.backtrace.first(3)) if event.exception&.backtrace
 
       parts.compact.join(" ")
     end
@@ -148,9 +146,7 @@ module Lapsoss
       end
 
       # Include environment if configured
-      if @include_environment && event.environment
-        components << event.environment
-      end
+      components << event.environment if @include_environment && event.environment
 
       # Generate hash from components
       content = components.compact.join("|")
@@ -194,18 +190,18 @@ module Lapsoss
 
       # Find first non-gem, non-framework line
       app_line = backtrace.find do |line|
-        !line.include?("/gems/") &&
-        !line.include?("/ruby/") &&
-        !line.include?("(eval)") &&
-        !line.start_with?("[")
+        line.exclude?("/gems/") &&
+          line.exclude?("/ruby/") &&
+          line.exclude?("(eval)") &&
+          !line.start_with?("[")
       end
 
       line_to_use = app_line || backtrace.first
 
       if @normalize_paths
         # Extract just filename:line_number
-        if line_to_use.match(%r{([^/]+):(\d+)})
-          "#{$1}:#{$2}"
+        if line_to_use =~ %r{([^/]+):(\d+)}
+          "#{::Regexp.last_match(1)}:#{::Regexp.last_match(2)}"
         else
           line_to_use
         end

data/lib/lapsoss/http_client.rb

@@ -8,7 +8,7 @@ require "zlib"
 module Lapsoss
   # HTTP client wrapper using Faraday with retry logic
   class HttpClient
-    USER_AGENT = "lapsoss/#{Lapsoss::VERSION}"
+    USER_AGENT = "lapsoss/#{Lapsoss::VERSION}".freeze
 
     def initialize(base_url, config = {})
       @base_url = base_url
@@ -53,26 +53,60 @@ module Lapsoss
         conn.options.open_timeout = @config[:timeout] || 5
 
         # Configure SSL
-        if @config.key?(:ssl_verify)
-          conn.ssl.verify = @config[:ssl_verify]
-        end
+        conn.ssl.verify = @config[:ssl_verify] if @config.key?(:ssl_verify)
 
         # Set user agent
         conn.headers["User-Agent"] = USER_AGENT
 
-        # Use default adapter
-        conn.adapter Faraday.default_adapter
+        # Auto-detect and use appropriate adapter
+        conn.adapter detect_optimal_adapter
       end
     end
 
+    def detect_optimal_adapter
+      if fiber_scheduler_active? && async_adapter_available? && !force_sync_mode?
+        log_adapter_selection(:async)
+        :async_http
+      else
+        log_adapter_selection(:sync)
+        Faraday.default_adapter
+      end
+    end
+
+    def fiber_scheduler_active?
+      Fiber.current_scheduler != nil
+    end
+
+    def async_adapter_available?
+      require "async/http/faraday"
+      true
+    rescue LoadError
+      false
+    end
+
+    def force_sync_mode?
+      Lapsoss.configuration.force_sync_http
+    end
+
+    def log_adapter_selection(adapter_type)
+      return unless Lapsoss.configuration.debug?
+
+      Lapsoss.configuration.logger&.debug(
+        "[Lapsoss::HttpClient] Using #{adapter_type} HTTP adapter " \
+        "(fiber_scheduler: #{fiber_scheduler_active?}, " \
+        "async_available: #{async_adapter_available?}, " \
+        "force_sync: #{force_sync_mode?})"
+      )
+    end
+
     def retry_options
       {
         max: @config[:max_retries] || 3,
         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