class NoisyGem
  def self.do_something_complex
    # Imagine complex logic here, perhaps involving external libraries
    raise StandardError, "Something went wrong deep inside the gem!"
  end
end

class MyApplicationController
  def process_request
    begin
      NoisyGem.do_something_complex
    rescue => e
      puts "--- Default Ruby Backtrace ---"
      puts e.backtrace.join("\n")
      # In a real app, this would be logged or sent to an error tracker
    end
  end
end

# Simulate an application request
MyApplicationController.new.process_request

# Expected (noisy) output will include lines from 'noisy_gem.rb' and Ruby internals

class BacktraceFilter
  # Define paths to exclude. Common candidates are gem installations or framework directories.
  # Adapt these regex patterns to match your specific environment and gemset.
  EXCLUDE_PATTERNS = [
    /gems\/[^\/]+\/gems\/(?!my_app_specific_gem)/, # Exclude most gems, allow 'my_app_specific_gem'
    /ruby\/[^\/]+\/lib\/ruby/, # Ruby stdlib
    /rvm\/gems/, # RVM-specific paths
    /bundler\/gems/ # Bundler internal paths
  ].freeze

  # Filter a given backtrace array
  def self.filter(backtrace)
    backtrace.reject do |line|
      EXCLUDE_PATTERNS.any? { |pattern| line.match?(pattern) }
    end
  end
end

class MyApplicationLogic
  def perform_critical_operation
    # Simulate an error within our application code
    raise ArgumentError, "Invalid input received for operation."
  end
end

begin
  MyApplicationLogic.new.perform_critical_operation
rescue => e
  original_backtrace = e.backtrace
  filtered_backtrace = BacktraceFilter.filter(original_backtrace)

  puts "--- Filtered Ruby Backtrace (Application-focused) ---"
  puts filtered_backtrace.join("\n")

  # We can also set the filtered backtrace on the exception itself if needed
  e.set_backtrace(filtered_backtrace)
  # raise e # Re-raise with the new backtrace, or log it.
end

# Run this code and compare the output to the default noisy backtrace. 
# Expect to see primarily lines from 'my_application_logic.rb' or other app files.
# Create a dummy gem directory to test the 'my_app_specific_gem' exclusion if desired.
# Example: mkdir -p .bundle/gems/my_app_specific_gem-1.0.0/lib
#          touch .bundle/gems/my_app_specific_gem-1.0.0/lib/my_app_specific_gem.rb
#          (ensure your EXCLUDE_PATTERNS handle your actual gem paths) 

require 'json'

# Define a custom exception class to carry additional context
class ContextualError < StandardError
  attr_reader :context

  def initialize(message, context = {})
    super(message)
    @context = context
  end

  # Override the message or add context to it for logging/reporting
  def message_with_context
    "#{message} (Context: #{JSON.generate(context)})"
  end

  # Optionally, format the backtrace with context if you are logging it directly
  def detailed_backtrace
    filtered_bt = BacktraceFilter.filter(backtrace || caller)
    [message_with_context] + filtered_bt
  end
end

# Assume BacktraceFilter is defined from the previous step
class BacktraceFilter
  EXCLUDE_PATTERNS = [
    /gems\/[^\/]+\/gems\//, # Exclude most gems
    /ruby\/[^\/]+\/lib\/ruby/
  ].freeze

  def self.filter(backtrace)
    backtrace.reject do |line|
      EXCLUDE_PATTERNS.any? { |pattern| line.match?(pattern) }
    end
  end
end

class UserAuthenticator
  def initialize(user_id)
    @user_id = user_id
  end

  def authenticate(credentials)
    # Simulate a failed authentication attempt
    if credentials[:password] != "secret"
      raise ContextualError.new(
        "Authentication failed",
        user_id: @user_id,
        attempted_email: credentials[:email],
        ip_address: "192.168.1.100", # Example dynamic context
        timestamp: Time.now.utc.iso8601
      )
    end
    true
  end
end

# Application entry point
begin
  authenticator = UserAuthenticator.new(42)
  authenticator.authenticate(email: "test@example.com", password: "wrong_password")
rescue ContextualError => e
  puts "--- Contextual Error Report ---"
  puts e.message_with_context
  puts e.detailed_backtrace.join("\n")
  puts "--- Raw Context ---"
  puts JSON.pretty_generate(e.context)
rescue => e
  puts "An unexpected error occurred: #{e.class}: #{e.message}"
  puts e.backtrace.join("\n")
end

require 'json'

# Re-using previous definitions for ContextualError and BacktraceFilter
# (Ensure these classes are defined in your environment before running)

class ContextualError < StandardError
  attr_reader :context
  def initialize(message, context = {}); super(message); @context = context; end
  def message_with_context; "#{message} (Context: #{JSON.generate(context)})"; end
  def detailed_backtrace; BacktraceFilter.filter(backtrace || caller).unshift(message_with_context); end
end

class BacktraceFilter
  EXCLUDE_PATTERNS = [
    /gems\/[^\/]+\/gems\//,
    /ruby\/[^\/]+\/lib\/ruby/
  ].freeze
  def self.filter(backtrace)
    backtrace.reject { |line| EXCLUDE_PATTERNS.any? { |pattern| line.match?(pattern) } }
  end
end

# Simulate an error reporting service (e.g., Sentry, Rollbar, or a custom logger)
class ErrorReporter
  def self.report(exception, additional_data = {})
    # Extract basic info
    error_class = exception.class.name
    error_message = exception.message

    # Get the backtrace, potentially filtered
    backtrace_lines = if exception.respond_to?(:detailed_backtrace)
                        exception.detailed_backtrace
                      else
                        BacktraceFilter.filter(exception.backtrace || caller)
                      end

    # Include custom context if available
    context_data = if exception.respond_to?(:context)
                     exception.context
                   else
                     {}
                   end

    # Combine all information for sending
    report_payload = {
      error_class: error_class,
      error_message: error_message,
      backtrace: backtrace_lines,
      context: context_data.merge(additional_data),
      timestamp: Time.now.utc.iso8601,
      environment: ENV['RACK_ENV'] || 'development'
    }

    puts "\n--- Sending Error Report to Service ---"
    puts JSON.pretty_generate(report_payload)
    # In a real system, this would involve HTTP requests to an external service
    # or writing to a persistent log file.
  end
end

# --- Application Logic with Error Handling ---
class ProductService
  def find_product(product_id)
    if product_id.nil? || product_id <= 0
      raise ContextualError.new(
        "Invalid product ID provided",
        product_id: product_id,
        user_session_id: "abc-123",
        request_path: "/products/#{product_id}"
      )
    end
    # Imagine database lookup here
    "Product #{product_id} details"
  end
end

# Simulate an incoming request that triggers an error
def handle_request(id)
  service = ProductService.new
  begin
    service.find_product(id)
  rescue ContextualError => e
    ErrorReporter.report(e, request_params: { id: id })
  rescue => e # Catch any other unexpected errors
    ErrorReporter.report(e, custom_tag: "unhandled_exception")
  end
end

puts "\n--- Simulating valid request ---"
handle_request(101)

puts "\n--- Simulating invalid request (triggers ContextualError) ---"
handle_request(0)

puts "\n--- Simulating another invalid request (triggers ContextualError) ---"
handle_request(nil)

# Simulate an error with a standard exception for comparison
begin
  raise RuntimeError, "A general unexpected issue"
rescue => e
  ErrorReporter.report(e)
end