lapsoss 0.1.0 → 0.3.0

data/lib/lapsoss/release_tracker.rb

@@ -13,10 +13,13 @@ module Lapsoss
       @cache_duration = configuration[:cache_duration] || 300 # 5 minutes
       @cached_release_info = nil
       @cache_timestamp = nil
+
+      # Auto-register rails_app_version provider if available
+      add_rails_app_version_provider if defined?(Rails) && Rails.application.respond_to?(:version)
     end
 
     def get_release_info
-      now = Time.now
+      now = Time.zone.now
 
       # Return cached info if still valid
       if @cached_release_info && @cache_timestamp && (now - @cache_timestamp) < @cache_duration
@@ -28,34 +31,26 @@ module Lapsoss
 
       # Add custom version providers
       @version_providers.each do |provider|
-        begin
-          if provider_info = provider.call
-            release_info.merge!(provider_info)
-          end
-        rescue StandardError => e
-          warn "Release provider failed: #{e.message}"
+        if provider_info = provider.call
+          release_info.merge!(provider_info)
         end
+      rescue StandardError => e
+        warn "Release provider failed: #{e.message}"
       end
 
       # Add Git information
-      if @git_enabled
-        if git_info = detect_git_info
-          release_info.merge!(git_info)
-        end
+      if @git_enabled && (git_info = detect_git_info)
+        release_info.merge!(git_info)
       end
 
       # Add environment information
-      if @environment_enabled
-        if env_info = detect_environment_info
-          release_info.merge!(env_info)
-        end
+      if @environment_enabled && (env_info = detect_environment_info)
+        release_info.merge!(env_info)
       end
 
       # Add deployment information
-      if @deployment_enabled
-        if deployment_info = detect_deployment_info
-          release_info.merge!(deployment_info)
-        end
+      if @deployment_enabled && (deployment_info = detect_deployment_info)
+        release_info.merge!(deployment_info)
       end
 
       # Generate release ID if not provided
@@ -77,6 +72,19 @@ module Lapsoss
       @cache_timestamp = nil
     end
 
+    def add_rails_app_version_provider
+      add_version_provider do
+        if defined?(Rails) && Rails.application.respond_to?(:version)
+          version = Rails.application.version
+          {
+            rails_app_version: version.to_s,
+            rails_app_version_cache_key: version.to_cache_key,
+            rails_app_environment: Rails.application.env
+          }
+        end
+      end
+    end
+
     private
 
     def detect_git_info
@@ -99,9 +107,7 @@ module Lapsoss
 
         # Get commit timestamp
         commit_timestamp = execute_git_command("log -1 --format=%ct")
-        if commit_timestamp && !commit_timestamp.empty?
-          git_info[:commit_timestamp] = Time.at(commit_timestamp.to_i)
-        end
+        git_info[:commit_timestamp] = Time.zone.at(commit_timestamp.to_i) if commit_timestamp.present?
 
         # Get commit message
         commit_message = execute_git_command("log -1 --format=%s")
@@ -113,11 +119,11 @@ module Lapsoss
 
         # Get tag if on a tag
         tag = execute_git_command("describe --exact-match --tags HEAD 2>/dev/null")
-        git_info[:tag] = tag if tag && !tag.empty?
+        git_info[:tag] = tag if tag.present?
 
         # Get latest tag
         latest_tag = execute_git_command("describe --tags --abbrev=0 2>/dev/null")
-        git_info[:latest_tag] = latest_tag if latest_tag && !latest_tag.empty?
+        git_info[:latest_tag] = latest_tag if latest_tag.present?
 
         # Get commits since latest tag
         if latest_tag
@@ -131,9 +137,7 @@ module Lapsoss
 
         # Get remote URL
         remote_url = execute_git_command("config --get remote.origin.url")
-        if remote_url
-          git_info[:remote_url] = sanitize_remote_url(remote_url)
-        end
+        git_info[:remote_url] = sanitize_remote_url(remote_url) if remote_url
 
         git_info
       rescue StandardError => e
@@ -145,9 +149,22 @@ module Lapsoss
     def detect_environment_info
       env_info = {}
 
-      # Application version from common environment variables
-      env_info[:app_version] = ENV["APP_VERSION"] if ENV["APP_VERSION"]
-      env_info[:version] = ENV["VERSION"] if ENV["VERSION"]
+      # Try rails_app_version first if available
+      if defined?(Rails) && Rails.application.respond_to?(:version)
+        env_info[:version] = Rails.application.version.to_s
+        env_info[:app_version] = Rails.application.version.to_s
+
+        # Add detailed version info
+        version_obj = Rails.application.version
+        env_info[:version_major] = version_obj.major
+        env_info[:version_minor] = version_obj.minor
+        env_info[:version_patch] = version_obj.patch
+        env_info[:version_prerelease] = version_obj.prerelease? if version_obj.respond_to?(:prerelease?)
+      else
+        # Fallback to environment variables
+        env_info[:app_version] = ENV["APP_VERSION"] if ENV["APP_VERSION"]
+        env_info[:version] = ENV["VERSION"] if ENV["VERSION"]
+      end
 
       # Environment detection
       env_info[:environment] = detect_environment
@@ -191,6 +208,9 @@ module Lapsoss
     end
 
     def detect_environment
+      # Try rails_app_version first if available
+      return Rails.application.env if defined?(Rails) && Rails.application.respond_to?(:env)
+
       return ENV["RAILS_ENV"] if ENV["RAILS_ENV"]
       return ENV["RACK_ENV"] if ENV["RACK_ENV"]
       return ENV["NODE_ENV"] if ENV["NODE_ENV"]
@@ -198,9 +218,7 @@ module Lapsoss
       return ENV["ENV"] if ENV["ENV"]
 
       # Try to detect from Rails if available
-      if defined?(Rails) && Rails.respond_to?(:env)
-        return Rails.env.to_s
-      end
+      return Rails.env.to_s if defined?(Rails) && Rails.respond_to?(:env)
 
       # Default fallback
       "unknown"
@@ -212,57 +230,57 @@ module Lapsoss
       # GitHub Actions
       if ENV["GITHUB_ACTIONS"]
         ci_info[:provider] = "github_actions"
-        ci_info[:run_id] = ENV["GITHUB_RUN_ID"]
-        ci_info[:run_number] = ENV["GITHUB_RUN_NUMBER"]
-        ci_info[:workflow] = ENV["GITHUB_WORKFLOW"]
-        ci_info[:actor] = ENV["GITHUB_ACTOR"]
-        ci_info[:repository] = ENV["GITHUB_REPOSITORY"]
-        ci_info[:ref] = ENV["GITHUB_REF"]
-        ci_info[:sha] = ENV["GITHUB_SHA"]
+        ci_info[:run_id] = ENV.fetch("GITHUB_RUN_ID", nil)
+        ci_info[:run_number] = ENV.fetch("GITHUB_RUN_NUMBER", nil)
+        ci_info[:workflow] = ENV.fetch("GITHUB_WORKFLOW", nil)
+        ci_info[:actor] = ENV.fetch("GITHUB_ACTOR", nil)
+        ci_info[:repository] = ENV.fetch("GITHUB_REPOSITORY", nil)
+        ci_info[:ref] = ENV.fetch("GITHUB_REF", nil)
+        ci_info[:sha] = ENV.fetch("GITHUB_SHA", nil)
       end
 
       # GitLab CI
       if ENV["GITLAB_CI"]
         ci_info[:provider] = "gitlab_ci"
-        ci_info[:pipeline_id] = ENV["CI_PIPELINE_ID"]
-        ci_info[:job_id] = ENV["CI_JOB_ID"]
-        ci_info[:job_name] = ENV["CI_JOB_NAME"]
-        ci_info[:commit_sha] = ENV["CI_COMMIT_SHA"]
-        ci_info[:commit_ref] = ENV["CI_COMMIT_REF_NAME"]
-        ci_info[:project_url] = ENV["CI_PROJECT_URL"]
+        ci_info[:pipeline_id] = ENV.fetch("CI_PIPELINE_ID", nil)
+        ci_info[:job_id] = ENV.fetch("CI_JOB_ID", nil)
+        ci_info[:job_name] = ENV.fetch("CI_JOB_NAME", nil)
+        ci_info[:commit_sha] = ENV.fetch("CI_COMMIT_SHA", nil)
+        ci_info[:commit_ref] = ENV.fetch("CI_COMMIT_REF_NAME", nil)
+        ci_info[:project_url] = ENV.fetch("CI_PROJECT_URL", nil)
       end
 
       # Jenkins
       if ENV["JENKINS_URL"]
         ci_info[:provider] = "jenkins"
-        ci_info[:build_number] = ENV["BUILD_NUMBER"]
-        ci_info[:build_id] = ENV["BUILD_ID"]
-        ci_info[:job_name] = ENV["JOB_NAME"]
-        ci_info[:build_url] = ENV["BUILD_URL"]
-        ci_info[:git_commit] = ENV["GIT_COMMIT"]
-        ci_info[:git_branch] = ENV["GIT_BRANCH"]
+        ci_info[:build_number] = ENV.fetch("BUILD_NUMBER", nil)
+        ci_info[:build_id] = ENV.fetch("BUILD_ID", nil)
+        ci_info[:job_name] = ENV.fetch("JOB_NAME", nil)
+        ci_info[:build_url] = ENV.fetch("BUILD_URL", nil)
+        ci_info[:git_commit] = ENV.fetch("GIT_COMMIT", nil)
+        ci_info[:git_branch] = ENV.fetch("GIT_BRANCH", nil)
       end
 
       # CircleCI
       if ENV["CIRCLECI"]
         ci_info[:provider] = "circleci"
-        ci_info[:build_num] = ENV["CIRCLE_BUILD_NUM"]
-        ci_info[:workflow_id] = ENV["CIRCLE_WORKFLOW_ID"]
-        ci_info[:job] = ENV["CIRCLE_JOB"]
-        ci_info[:project_reponame] = ENV["CIRCLE_PROJECT_REPONAME"]
-        ci_info[:sha1] = ENV["CIRCLE_SHA1"]
-        ci_info[:branch] = ENV["CIRCLE_BRANCH"]
+        ci_info[:build_num] = ENV.fetch("CIRCLE_BUILD_NUM", nil)
+        ci_info[:workflow_id] = ENV.fetch("CIRCLE_WORKFLOW_ID", nil)
+        ci_info[:job] = ENV.fetch("CIRCLE_JOB", nil)
+        ci_info[:project_reponame] = ENV.fetch("CIRCLE_PROJECT_REPONAME", nil)
+        ci_info[:sha1] = ENV.fetch("CIRCLE_SHA1", nil)
+        ci_info[:branch] = ENV.fetch("CIRCLE_BRANCH", nil)
       end
 
       # Travis CI
       if ENV["TRAVIS"]
         ci_info[:provider] = "travis"
-        ci_info[:build_id] = ENV["TRAVIS_BUILD_ID"]
-        ci_info[:build_number] = ENV["TRAVIS_BUILD_NUMBER"]
-        ci_info[:job_id] = ENV["TRAVIS_JOB_ID"]
-        ci_info[:commit] = ENV["TRAVIS_COMMIT"]
-        ci_info[:branch] = ENV["TRAVIS_BRANCH"]
-        ci_info[:tag] = ENV["TRAVIS_TAG"]
+        ci_info[:build_id] = ENV.fetch("TRAVIS_BUILD_ID", nil)
+        ci_info[:build_number] = ENV.fetch("TRAVIS_BUILD_NUMBER", nil)
+        ci_info[:job_id] = ENV.fetch("TRAVIS_JOB_ID", nil)
+        ci_info[:commit] = ENV.fetch("TRAVIS_COMMIT", nil)
+        ci_info[:branch] = ENV.fetch("TRAVIS_BRANCH", nil)
+        ci_info[:tag] = ENV.fetch("TRAVIS_TAG", nil)
       end
 
       ci_info
@@ -273,11 +291,11 @@ module Lapsoss
 
       {
         platform: "heroku",
-        app_name: ENV["HEROKU_APP_NAME"],
-        dyno: ENV["DYNO"],
-        slug_commit: ENV["HEROKU_SLUG_COMMIT"],
-        release_version: ENV["HEROKU_RELEASE_VERSION"],
-        slug_description: ENV["HEROKU_SLUG_DESCRIPTION"]
+        app_name: ENV.fetch("HEROKU_APP_NAME", nil),
+        dyno: ENV.fetch("DYNO", nil),
+        slug_commit: ENV.fetch("HEROKU_SLUG_COMMIT", nil),
+        release_version: ENV.fetch("HEROKU_RELEASE_VERSION", nil),
+        slug_description: ENV.fetch("HEROKU_SLUG_DESCRIPTION", nil)
       }
     end
 
@@ -287,17 +305,17 @@ module Lapsoss
       if ENV["AWS_EXECUTION_ENV"]
         info[:platform] = "aws"
         info[:execution_env] = ENV["AWS_EXECUTION_ENV"]
-        info[:region] = ENV["AWS_REGION"] || ENV["AWS_DEFAULT_REGION"]
-        info[:function_name] = ENV["AWS_LAMBDA_FUNCTION_NAME"]
-        info[:function_version] = ENV["AWS_LAMBDA_FUNCTION_VERSION"]
+        info[:region] = ENV["AWS_REGION"] || ENV.fetch("AWS_DEFAULT_REGION", nil)
+        info[:function_name] = ENV.fetch("AWS_LAMBDA_FUNCTION_NAME", nil)
+        info[:function_version] = ENV.fetch("AWS_LAMBDA_FUNCTION_VERSION", nil)
       end
 
       # EC2 metadata (if available)
       if ENV["EC2_INSTANCE_ID"]
         info[:platform] = "aws_ec2"
         info[:instance_id] = ENV["EC2_INSTANCE_ID"]
-        info[:instance_type] = ENV["EC2_INSTANCE_TYPE"]
-        info[:availability_zone] = ENV["EC2_AVAILABILITY_ZONE"]
+        info[:instance_type] = ENV.fetch("EC2_INSTANCE_TYPE", nil)
+        info[:availability_zone] = ENV.fetch("EC2_AVAILABILITY_ZONE", nil)
       end
 
       info
@@ -309,18 +327,18 @@ module Lapsoss
       if ENV["GOOGLE_CLOUD_PROJECT"]
         info[:platform] = "gcp"
         info[:project] = ENV["GOOGLE_CLOUD_PROJECT"]
-        info[:region] = ENV["GOOGLE_CLOUD_REGION"]
-        info[:function_name] = ENV["FUNCTION_NAME"]
-        info[:function_signature_type] = ENV["FUNCTION_SIGNATURE_TYPE"]
+        info[:region] = ENV.fetch("GOOGLE_CLOUD_REGION", nil)
+        info[:function_name] = ENV.fetch("FUNCTION_NAME", nil)
+        info[:function_signature_type] = ENV.fetch("FUNCTION_SIGNATURE_TYPE", nil)
       end
 
       # App Engine
       if ENV["GAE_APPLICATION"]
         info[:platform] = "gcp_app_engine"
         info[:application] = ENV["GAE_APPLICATION"]
-        info[:service] = ENV["GAE_SERVICE"]
-        info[:version] = ENV["GAE_VERSION"]
-        info[:runtime] = ENV["GAE_RUNTIME"]
+        info[:service] = ENV.fetch("GAE_SERVICE", nil)
+        info[:version] = ENV.fetch("GAE_VERSION", nil)
+        info[:runtime] = ENV.fetch("GAE_RUNTIME", nil)
       end
 
       info
@@ -332,9 +350,9 @@ module Lapsoss
       if ENV["WEBSITE_SITE_NAME"]
         info[:platform] = "azure"
         info[:site_name] = ENV["WEBSITE_SITE_NAME"]
-        info[:resource_group] = ENV["WEBSITE_RESOURCE_GROUP"]
-        info[:subscription_id] = ENV["WEBSITE_OWNER_NAME"]
-        info[:sku] = ENV["WEBSITE_SKU"]
+        info[:resource_group] = ENV.fetch("WEBSITE_RESOURCE_GROUP", nil)
+        info[:subscription_id] = ENV.fetch("WEBSITE_OWNER_NAME", nil)
+        info[:sku] = ENV.fetch("WEBSITE_SKU", nil)
       end
 
       info
@@ -346,8 +364,8 @@ module Lapsoss
       if ENV["DOCKER_CONTAINER_ID"] || File.exist?("/.dockerenv")
         info[:platform] = "docker"
         info[:container_id] = ENV["DOCKER_CONTAINER_ID"]
-        info[:image] = ENV["DOCKER_IMAGE"]
-        info[:tag] = ENV["DOCKER_TAG"]
+        info[:image] = ENV.fetch("DOCKER_IMAGE", nil)
+        info[:tag] = ENV.fetch("DOCKER_TAG", nil)
       end
 
       info
@@ -358,11 +376,11 @@ module Lapsoss
 
       if ENV["KUBERNETES_SERVICE_HOST"]
         info[:platform] = "kubernetes"
-        info[:namespace] = ENV["KUBERNETES_NAMESPACE"]
-        info[:pod_name] = ENV["HOSTNAME"]
-        info[:service_account] = ENV["KUBERNETES_SERVICE_ACCOUNT"]
-        info[:cluster_name] = ENV["CLUSTER_NAME"]
-        info[:node_name] = ENV["NODE_NAME"]
+        info[:namespace] = ENV.fetch("KUBERNETES_NAMESPACE", nil)
+        info[:pod_name] = ENV.fetch("HOSTNAME", nil)
+        info[:service_account] = ENV.fetch("KUBERNETES_SERVICE_ACCOUNT", nil)
+        info[:cluster_name] = ENV.fetch("CLUSTER_NAME", nil)
+        info[:node_name] = ENV.fetch("NODE_NAME", nil)
       end
 
       info
@@ -393,16 +411,14 @@ module Lapsoss
       ]
 
       formats.each do |format|
-        begin
-          return Time.strptime(time_str, format)
-        rescue ArgumentError
-          next
-        end
+        return Time.strptime(time_str, format)
+      rescue ArgumentError
+        next
       end
 
       # Try parsing as integer (Unix timestamp)
       begin
-        return Time.at(time_str.to_i) if time_str.match?(/^\d+$/)
+        return Time.zone.at(time_str.to_i) if time_str.match?(/^\d+$/)
       rescue ArgumentError
         nil
       end
@@ -439,115 +455,4 @@ module Lapsoss
       end
     end
   end
-
-  # Built-in release providers for common scenarios
-  class ReleaseProviders
-    def self.from_file(file_path)
-      lambda do
-        return nil unless File.exist?(file_path)
-
-        content = File.read(file_path).strip
-        return nil if content.empty?
-
-        # Try to parse as JSON first
-        begin
-          JSON.parse(content)
-        rescue JSON::ParserError
-          # Treat as plain text version
-          { version: content }
-        end
-      end
-    end
-
-    def self.from_ruby_constant(constant_name)
-      lambda do
-        begin
-          constant = Object.const_get(constant_name)
-          { version: constant.to_s }
-        rescue NameError
-          nil
-        end
-      end
-    end
-
-    def self.from_gemfile_lock
-      lambda do
-        return nil unless File.exist?("Gemfile.lock")
-
-        content = File.read("Gemfile.lock")
-
-        # Extract gems with versions
-        gems = {}
-        content.scan(/^\s{4}(\w+)\s+\(([^)]+)\)/).each do |name, version|
-          gems[name] = version
-        end
-
-        { gems: gems }
-      end
-    end
-
-    def self.from_package_json
-      lambda do
-        return nil unless File.exist?("package.json")
-
-        begin
-          package_info = JSON.parse(File.read("package.json"))
-          {
-            version: package_info["version"],
-            name: package_info["name"],
-            dependencies: package_info["dependencies"]&.keys
-          }.compact
-        rescue JSON::ParserError
-          nil
-        end
-      end
-    end
-
-    def self.from_rails_application
-      lambda do
-        return nil unless defined?(Rails) && Rails.respond_to?(:application)
-
-        app = Rails.application
-        return nil unless app
-
-        info = {
-          rails_version: Rails.version,
-          environment: Rails.env,
-          root: Rails.root.to_s
-        }
-
-        # Get application version if defined
-        if app.class.respond_to?(:version)
-          info[:app_version] = app.class.version
-        end
-
-        # Get application name
-        if app.class.respond_to?(:name)
-          info[:app_name] = app.class.name
-        end
-
-        info
-      end
-    end
-
-    def self.from_capistrano
-      lambda do
-        # Check for Capistrano deployment files
-        %w[REVISION current/REVISION].each do |file|
-          next unless File.exist?(file)
-
-          revision = File.read(file).strip
-          next if revision.empty?
-
-          return {
-            revision: revision,
-            deployed_at: File.mtime(file),
-            deployment_method: "capistrano"
-          }
-        end
-
-        nil
-      end
-    end
-  end
 end

data/lib/lapsoss/router.rb

@@ -9,11 +9,9 @@ module Lapsoss
       # @param event [Lapsoss::Event] The event to process.
       def process_event(event)
         Registry.instance.active.each do |adapter|
-          begin
-            adapter.capture(event)
-          rescue => e
-            handle_adapter_error(adapter, event, e)
-          end
+          adapter.capture(event)
+        rescue StandardError => e
+          handle_adapter_error(adapter, event, e)
         end
       end
 

data/lib/lapsoss/sampling/adaptive_sampler.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Lapsoss
+  module Sampling
+    class AdaptiveSampler < Base
+      def initialize(target_rate: 1.0, adjustment_period: 60)
+        @target_rate = target_rate
+        @adjustment_period = adjustment_period
+        @current_rate = target_rate
+        @events_count = 0
+        @last_adjustment = Time.zone.now
+        @mutex = Mutex.new
+      end
+
+      def sample?(_event, _hint = {})
+        @mutex.synchronize do
+          @events_count += 1
+
+          # Adjust rate periodically
+          now = Time.zone.now
+          if now - @last_adjustment > @adjustment_period
+            adjust_rate
+            @last_adjustment = now
+            @events_count = 0
+          end
+        end
+
+        @current_rate > rand
+      end
+
+      attr_reader :current_rate
+
+      private
+
+      def adjust_rate
+        # Simple adaptive logic - can be enhanced based on system metrics
+        # For now, just ensure we don't drift too far from target
+        if @events_count > 100 # High volume
+          @current_rate = [ @current_rate * 0.9, @target_rate * 0.1 ].max
+        elsif @events_count < 10 # Low volume
+          @current_rate = [ @current_rate * 1.1, @target_rate ].min
+        end
+      end
+    end
+  end
+end

data/lib/lapsoss/sampling/base.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Lapsoss
+  module Sampling
+    class Base
+      def sample?(_event, _hint = {})
+        true
+      end
+    end
+  end
+end

data/lib/lapsoss/sampling/composite_sampler.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Lapsoss
+  module Sampling
+    class CompositeSampler < Base
+      def initialize(app = nil, samplers: [], strategy: :all)
+        @app = app
+        @samplers = samplers
+        @strategy = strategy
+      end
+
+      def sample?(event, hint = {})
+        case @strategy
+        when :all
+          @samplers.all? { |sampler| sampler.sample?(event, hint) }
+        when :any
+          @samplers.any? { |sampler| sampler.sample?(event, hint) }
+        when :first
+          @samplers.first&.sample?(event, hint) || true
+        else
+          raise ArgumentError, "Unknown strategy: #{@strategy}"
+        end
+      end
+    end
+  end
+end

data/lib/lapsoss/sampling/consistent_hash_sampler.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "digest"
+
+module Lapsoss
+  module Sampling
+    class ConsistentHashSampler < Base
+      def initialize(rate:, key_extractor: nil)
+        @rate = rate
+        @key_extractor = key_extractor || method(:default_key_extractor)
+        @threshold = (rate * 0xFFFFFFFF).to_i
+      end
+
+      def sample?(event, hint = {})
+        key = @key_extractor.call(event, hint)
+        return @rate > rand unless key
+
+        hash_value = Digest::MD5.hexdigest(key.to_s)[0, 8].to_i(16)
+        hash_value <= @threshold
+      end
+
+      private
+
+      def default_key_extractor(event, _hint)
+        # Use fingerprint for consistent sampling
+        event.fingerprint
+      end
+    end
+  end
+end

data/lib/lapsoss/sampling/exception_type_sampler.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Lapsoss
+  module Sampling
+    class ExceptionTypeSampler < Base
+      def initialize(rates: {})
+        @rates = rates
+        @default_rate = rates.fetch(:default, 1.0)
+      end
+
+      def sample?(event, _hint = {})
+        return @default_rate > rand unless event.exception
+
+        exception_class = event.exception.class
+        rate = find_rate_for_exception(exception_class)
+        rate > rand
+      end
+
+      private
+
+      def find_rate_for_exception(exception_class)
+        # Check exact class match first
+        return @rates[exception_class] if @rates.key?(exception_class)
+
+        # Check inheritance hierarchy
+        @rates.each do |klass, rate|
+          return rate if klass.is_a?(Class) && exception_class <= klass
+        end
+
+        # Check string/regex patterns
+        @rates.each do |pattern, rate|
+          case pattern
+          when String
+            return rate if exception_class.name.include?(pattern)
+          when Regexp
+            return rate if exception_class.name.match?(pattern)
+          end
+        end
+
+        @default_rate
+      end
+    end
+  end
+end