chronos-ruby 0.3.0.pre.1 → 0.5.0.pre.1

data/lib/chronos/configuration.rb

@@ -1,4 +1,5 @@
 require "uri"
+require "chronos/configuration/validation"
 
 module Chronos
   # Mutable configuration used only while the Chronos agent is being set up.
@@ -19,11 +20,13 @@ module Chronos
   #   config.host = 'https://chronos.example.com'
   #   snapshot = config.snapshot
   class Configuration
+    include Internal::ConfigurationValidation
     DEFAULT_BLOCKLIST_KEYS = %w(
       password password_confirmation passwd secret api_key apikey authorization
       token access_token refresh_token private_key client_secret cookie set-cookie
       session credit_card card_number cvv cpf cnpj
     ).freeze
+    CONTEXT_STORE_METHODS = [:get, :set, :clear, :with_context].freeze
 
     ATTRIBUTES = [
       :project_id, :project_key, :host, :environment, :app_version,
@@ -35,7 +38,9 @@ module Chronos
       :retry_base_interval, :retry_max_interval, :retry_jitter,
       :backlog_size, :circuit_failure_threshold, :circuit_reset_timeout,
       :remote_configuration, :remote_config_max_bytes, :sampling_rate,
-      :enabled_event_types, :max_remote_send_interval
+      :enabled_event_types, :max_remote_send_interval, :context_store,
+      :breadcrumb_capacity, :breadcrumb_max_bytes, :rails_enabled,
+      :rails_capture_in_console, :rails_capture_in_test, :rails_capture_user_agent
     ].freeze
 
     attr_accessor(*ATTRIBUTES)
@@ -44,6 +49,7 @@ module Chronos
       initialize_core_defaults
       initialize_privacy_defaults
       initialize_resilience_defaults
+      initialize_rails_defaults
     end
 
     def snapshot
@@ -57,7 +63,7 @@ module Chronos
       validation_errors.empty?
     end
 
-    def validation_errors
+    def validation_errors # rubocop:disable Metrics/AbcSize
       errors = []
       if enabled
         errors << "project_id is required" if blank?(project_id)
@@ -71,6 +77,7 @@ module Chronos
       errors << "max_payload_size must be a positive integer" unless positive_integer?(max_payload_size)
       errors.concat(resilience_errors)
       errors.concat(privacy_errors)
+      errors.concat(context_errors)
       errors
     end
 
@@ -97,6 +104,16 @@ module Chronos
       @user_agent = "chronos-ruby/#{Chronos::VERSION}"
       @max_payload_size = 1_048_576
       @gzip = false
+      @context_store = :thread_local
+      @breadcrumb_capacity = 20
+      @breadcrumb_max_bytes = 2048
+    end
+
+    def initialize_rails_defaults
+      @rails_enabled = true
+      @rails_capture_in_console = false
+      @rails_capture_in_test = false
+      @rails_capture_user_agent = false
     end
 
     def initialize_privacy_defaults
@@ -118,55 +135,10 @@ module Chronos
       @remote_configuration = true
       @remote_config_max_bytes = 4096
       @sampling_rate = 1.0
-      @enabled_event_types = ["exception"]
+      @enabled_event_types = ["exception", "request", "query", "job", "cache"]
       @max_remote_send_interval = 60.0
     end
 
-    def resilience_errors
-      errors = []
-      errors.concat(retry_errors)
-      errors.concat(backlog_and_circuit_errors)
-      errors.concat(remote_policy_errors)
-      errors
-    end
-
-    def retry_errors
-      errors = []
-      errors << "max_retries must be a non-negative integer" unless non_negative_integer?(max_retries)
-      errors << "retry_base_interval must be greater than zero" unless positive_number?(retry_base_interval)
-      errors << "retry_max_interval must be greater than zero" unless positive_number?(retry_max_interval)
-      if positive_number?(retry_base_interval) && positive_number?(retry_max_interval) &&
-         retry_max_interval < retry_base_interval
-        errors << "retry_max_interval must be greater than or equal to retry_base_interval"
-      end
-      errors << "retry_jitter must be between zero and one" unless rate?(retry_jitter)
-      errors
-    end
-
-    def backlog_and_circuit_errors
-      errors = []
-      errors << "backlog_size must be a non-negative integer" unless non_negative_integer?(backlog_size)
-      unless positive_integer?(circuit_failure_threshold)
-        errors << "circuit_failure_threshold must be a positive integer"
-      end
-      errors << "circuit_reset_timeout must be greater than zero" unless positive_number?(circuit_reset_timeout)
-      errors
-    end
-
-    def remote_policy_errors
-      errors = []
-      unless [true, false].include?(remote_configuration)
-        errors << "remote_configuration must be true or false"
-      end
-      errors << "remote_config_max_bytes must be a positive integer" unless positive_integer?(remote_config_max_bytes)
-      errors << "sampling_rate must be between zero and one" unless rate?(sampling_rate)
-      unless enabled_event_types.is_a?(Array) && enabled_event_types.all? { |value| value.is_a?(String) }
-        errors << "enabled_event_types must contain only String values"
-      end
-      errors << "max_remote_send_interval must be greater than zero" unless positive_number?(max_remote_send_interval)
-      errors
-    end
-
     def to_hash
       ATTRIBUTES.each_with_object({}) do |attribute, values|
         value = public_send(attribute)
@@ -174,39 +146,6 @@ module Chronos
       end
     end
 
-    def privacy_errors
-      errors = []
-      errors << "blocklist_keys must be an array" unless blocklist_keys.is_a?(Array)
-      errors << "allowlist_keys must be an array" unless allowlist_keys.is_a?(Array)
-      errors << "hash_keys must be an array" unless hash_keys.is_a?(Array)
-      errors.concat(matcher_errors("blocklist_keys", blocklist_keys))
-      errors.concat(matcher_errors("allowlist_keys", allowlist_keys))
-      errors.concat(matcher_errors("hash_keys", hash_keys))
-      errors.concat(filter_errors)
-      errors.concat(anonymization_errors)
-      errors
-    end
-
-    def filter_errors
-      return ["filters must be an array"] unless filters.is_a?(Array)
-      return [] if filters.all? { |filter| filter.respond_to?(:call) }
-
-      ["filters must contain only callable objects"]
-    end
-
-    def anonymization_errors
-      return [] if anonymize_ip == true || anonymize_ip == false
-
-      ["anonymize_ip must be true or false"]
-    end
-
-    def matcher_errors(name, values)
-      return [] unless values.is_a?(Array)
-      return [] if values.all? { |value| value.is_a?(String) || value.is_a?(Symbol) || value.is_a?(Regexp) }
-
-      ["#{name} must contain only String, Symbol, or Regexp values"]
-    end
-
     def deep_copy(value)
       case value
       when Hash
@@ -220,18 +159,6 @@ module Chronos
       end
     end
 
-    def host_errors
-      return ["host is required"] if blank?(host)
-
-      uri = URI.parse(host.to_s)
-      return ["host must be an absolute HTTP or HTTPS URL"] unless uri.host && %w(http https).include?(uri.scheme)
-      return ["host must use HTTPS unless ssl_verify is explicitly disabled"] if uri.scheme != "https" && ssl_verify
-
-      []
-    rescue URI::InvalidURIError
-      ["host must be a valid URL"]
-    end
-
     def blank?(value)
       value.nil? || value.to_s.strip.empty?
     end
@@ -251,46 +178,7 @@ module Chronos
     def rate?(value)
       value.is_a?(Numeric) && value >= 0.0 && value <= 1.0
     end
-
-    # Immutable configuration shared by all runtime components.
-    #
-    # @responsibility Expose validated settings without mutable containers.
-    # @motivation Keep capture behavior stable while multiple threads run.
-    # @limits It cannot be edited after creation.
-    # @thread_safety Safe to share between threads after construction.
-    # @compatibility Ruby 2.2.10 through Ruby 2.6.
-    class Snapshot
-      attr_reader(*ATTRIBUTES)
-
-      def initialize(values)
-        ATTRIBUTES.each do |attribute|
-          value = values[attribute]
-          deep_freeze(value)
-          instance_variable_set("@#{attribute}", value)
-        end
-        freeze
-      end
-
-      def enabled_for_environment?
-        enabled && !ignored_environments.map(&:to_s).include?(environment.to_s)
-      end
-
-      private
-
-      def deep_freeze(value)
-        return value if value.respond_to?(:call)
-
-        case value
-        when Hash
-          value.each do |key, child|
-            deep_freeze(key)
-            deep_freeze(child)
-          end
-        when Array
-          value.each { |child| deep_freeze(child) }
-        end
-        value.freeze
-      end
-    end
   end
 end
+
+require "chronos/configuration/snapshot"

data/lib/chronos/core/breadcrumb.rb

@@ -0,0 +1,126 @@
+require "json"
+require "time"
+
+module Chronos
+  module Core
+    # Immutable, bounded diagnostic marker attached to an execution.
+    #
+    # @responsibility Normalize one breadcrumb without retaining raw application objects.
+    # @motivation Preserve useful events leading to an exception with predictable memory use.
+    # @limits It does not capture logs, SQL, bodies, or HTTP calls automatically.
+    # @collaborators SafeSerializer and BreadcrumbBuffer.
+    # @thread_safety Immutable after construction.
+    # @compatibility Ruby 2.2.10 through Ruby 2.6.
+    # @example
+    #   breadcrumb.to_h #=> {"category"=>"custom", ...}
+    # @errors Unserializable metadata is replaced by SafeSerializer placeholders.
+    # @performance Metadata traversal has strict depth, node, item, and byte limits.
+    class Breadcrumb
+      CATEGORIES = %w(custom log request query external_http cache job).freeze
+
+      def initialize(attributes, clock = nil, max_bytes = 2048)
+        attributes = {} unless attributes.is_a?(Hash)
+        clock ||= proc { Time.now }
+        serializer = SafeSerializer.new(
+          :max_depth => 5, :max_keys => 20, :max_items => 20,
+          :max_string_bytes => 512, :max_nodes => 100
+        )
+        @data = serializer.call(build_data(attributes, clock))
+        @data = compact_data(@data, max_bytes) if JSON.generate(@data).bytesize > max_bytes
+        deep_freeze(@data)
+        freeze
+      end
+
+      def to_h
+        @data
+      end
+
+      private
+
+      def build_data(attributes, clock)
+        category = value(attributes, :category).to_s
+        category = "custom" unless CATEGORIES.include?(category)
+        {
+          "category" => category,
+          "message" => value(attributes, :message).to_s,
+          "metadata" => value(attributes, :metadata) || {},
+          "timestamp" => clock.call.utc.iso8601(6)
+        }
+      end
+
+      def compact_data(data, max_bytes)
+        message_limit = [max_bytes / 4, 32].max
+        compacted = {
+          "category" => data["category"],
+          "message" => SafeSerializer.new.call(data["message"], :max_string_bytes => message_limit),
+          "metadata" => {"_truncated" => true},
+          "timestamp" => data["timestamp"]
+        }
+        trim_compacted_message(compacted, max_bytes)
+      end
+
+      def trim_compacted_message(compacted, max_bytes)
+        while JSON.generate(compacted).bytesize > max_bytes && !compacted["message"].empty?
+          length = [compacted["message"].bytesize - 16, 0].max
+          compacted["message"] = SafeSerializer.new.call(
+            compacted["message"].byteslice(0, length).to_s,
+            :max_string_bytes => length
+          )
+        end
+        compacted
+      end
+
+      def value(attributes, key)
+        attributes.key?(key) ? attributes[key] : attributes[key.to_s]
+      end
+
+      def deep_freeze(value)
+        if value.is_a?(Hash)
+          value.each do |key, child|
+            deep_freeze(key)
+            deep_freeze(child)
+          end
+        elsif value.is_a?(Array)
+          value.each { |child| deep_freeze(child) }
+        end
+        value.freeze
+      end
+    end
+
+    # Fixed-size circular collection of execution breadcrumbs.
+    #
+    # @responsibility Retain only the newest bounded breadcrumbs for one execution.
+    # @motivation Prevent long requests or noisy instrumentation from growing memory indefinitely.
+    # @limits It is process memory only and does not collect events by itself.
+    # @collaborators Breadcrumb and Agent.
+    # @thread_safety Intended for one execution thread; snapshots are immutable values.
+    # @compatibility Ruby 2.2.10 through Ruby 2.6.
+    # @example
+    #   buffer.add(:category => "custom", :message => "started")
+    # @errors Invalid attributes are normalized into a safe breadcrumb.
+    # @performance Add is constant time and storage never exceeds capacity.
+    class BreadcrumbBuffer
+      def initialize(capacity, max_bytes = 2048)
+        raise ArgumentError, "capacity must be a positive integer" unless capacity.is_a?(Integer) && capacity > 0
+
+        @capacity = capacity
+        @max_bytes = max_bytes
+        @items = []
+      end
+
+      def add(attributes)
+        @items.shift if @items.length >= @capacity
+        @items << Breadcrumb.new(attributes, nil, @max_bytes)
+        true
+      end
+
+      def to_a
+        @items.map(&:to_h)
+      end
+
+      def size
+        @items.size
+      end
+    end
+  end
+end

data/lib/chronos/core/telemetry_event.rb

@@ -0,0 +1,106 @@
+require "securerandom"
+require "time"
+
+module Chronos
+  module Core
+    # Immutable framework telemetry event normalized to the Chronos v1 envelope.
+    #
+    # @responsibility Carry a bounded event type, timestamp, context, and payload.
+    # @motivation Let integrations report metrics without depending on exception notices.
+    # @limits It does not sanitize, serialize, enqueue, or deliver itself.
+    # @collaborators TelemetrySerializer and framework integrations.
+    # @thread_safety Immutable after construction and safe to share.
+    # @compatibility Ruby 2.2.10 through Ruby 2.6.
+    # @example
+    #   event = Chronos::Core::TelemetryEvent.new("request", {"duration_ms" => 12.0})
+    # @errors Unsupported types raise ArgumentError during construction.
+    # @performance Construction is linear in supplied context and payload size.
+    class TelemetryEvent
+      TYPES = %w(request query job cache).freeze
+
+      attr_reader :event_id, :event_type, :timestamp, :context, :payload
+
+      def initialize(event_type, payload = {}, context = {}, options = {})
+        type = event_type.to_s
+        raise ArgumentError, "unsupported telemetry event type" unless TYPES.include?(type)
+
+        clock = options[:clock] || proc { Time.now }
+        @event_id = (options[:event_id] || SecureRandom.uuid).to_s.freeze
+        @event_type = type.freeze
+        @timestamp = clock.call.utc.iso8601(6).freeze
+        @context = deep_freeze(context.is_a?(Hash) ? context : {})
+        @payload = deep_freeze(payload.is_a?(Hash) ? payload : {})
+        freeze
+      end
+
+      private
+
+      def deep_freeze(value)
+        if value.is_a?(Hash)
+          value.each do |key, child|
+            deep_freeze(key)
+            deep_freeze(child)
+          end
+        elsif value.is_a?(Array)
+          value.each { |child| deep_freeze(child) }
+        end
+        value.freeze
+      end
+    end
+
+    # Serializes framework telemetry into the common Chronos event envelope.
+    #
+    # @responsibility Sanitize telemetry, normalize JSON primitives, and enforce payload size.
+    # @motivation Give Rails subscribers the same privacy and delivery boundary as exceptions.
+    # @limits It accepts only TelemetryEvent values and does not perform delivery.
+    # @collaborators TelemetryEvent, Sanitizer, SafeSerializer, RuntimeInfo, and SerializedEvent.
+    # @thread_safety Stateless apart from immutable configuration.
+    # @compatibility Ruby 2.2.10 through Ruby 2.6.
+    # @example
+    #   serialized = serializer.call(event)
+    # @errors Oversized events raise Chronos::Error and are contained by CaptureTelemetry.
+    # @performance Traversal and output bytes are bounded by existing serializer budgets.
+    class TelemetrySerializer
+      def initialize(config, clock = nil, options = {})
+        @config = config
+        @clock = clock || proc { Time.now }
+        @sanitizer = options[:sanitizer] || Sanitizer.new(config)
+        @safe_serializer = options[:safe_serializer] || SafeSerializer.new
+        @max_payload_size = options[:max_payload_size] || proc { @config.max_payload_size }
+        @runtime_info = RuntimeInfo.new
+      end
+
+      def call(event)
+        raise ArgumentError, "event must be a TelemetryEvent" unless event.is_a?(TelemetryEvent)
+
+        envelope = @safe_serializer.call(@sanitizer.call(build_envelope(event)))
+        body = JSON.generate(envelope)
+        body = JSON.generate(compact_envelope(envelope)) if body.bytesize > @max_payload_size.call
+        raise Error, "event exceeds max_payload_size" if body.bytesize > @max_payload_size.call
+
+        SerializedEvent.new(event.event_id, body)
+      end
+
+      private
+
+      def build_envelope(event)
+        runtime = @runtime_info.call
+        {
+          "schema_version" => "1.0", "event_id" => event.event_id,
+          "event_type" => event.event_type, "occurred_at" => event.timestamp,
+          "sent_at" => @clock.call.utc.iso8601(6), "project_key" => @config.project_id,
+          "environment" => @config.environment,
+          "service" => {"name" => @config.service_name, "version" => @config.app_version,
+                        "instance_id" => runtime[:host]},
+          "runtime" => runtime[:runtime], "context" => event.context, "payload" => event.payload
+        }
+      end
+
+      def compact_envelope(envelope)
+        envelope["context"] = {"_truncated" => true}
+        envelope["payload"] = {"_truncated" => true}
+        envelope
+      end
+    end
+  end
+end

data/lib/chronos/integrations/rack/middleware.rb

@@ -0,0 +1,156 @@
+require "securerandom"
+
+module Chronos
+  module Integrations
+    module Rack
+      # Captures unhandled Rack exceptions while preserving Rack semantics.
+      #
+      # @responsibility Build bounded request context, notify Chronos, and re-raise the original exception.
+      # @motivation Provide automatic error capture without coupling the core to Rack.
+      # @limits It never reads rack.input, enumerates response bodies, or infers Rails routes.
+      # @collaborators Rack application and the Chronos facade or Agent.
+      # @thread_safety Shared instances keep no per-request mutable state.
+      # @compatibility Rack 1.x/2.x protocol; Ruby 2.2.10 through Ruby 2.6.
+      # @example
+      #   use Chronos::Integrations::Rack::Middleware
+      # @errors Notification failures are contained; the application exception is always re-raised.
+      # @performance Adds bounded hash construction and monotonic-clock reads per request.
+      class Middleware
+        def initialize(app, options = {})
+          @app = app
+          @notifier = options[:notifier] || Chronos
+          @include_user_agent = options[:include_user_agent] || false
+          @clock = options[:clock] || proc { monotonic_time }
+        end
+
+        def call(env)
+          started_at = @clock.call
+          base = request_capture_context(env)
+          @notifier.with_context(base) do
+            add_request_breadcrumb("request started", base)
+            call_application(env, base, started_at)
+          end
+        end
+
+        private
+
+        def call_application(env, base, started_at)
+          response = @app.call(env)
+          status = response[0]
+          headers = response[1]
+          add_request_breadcrumb("request completed", dynamic_request_context(base, status, headers, started_at))
+          response
+        rescue Exception => error # rubocop:disable Lint/RescueException
+          context = dynamic_request_context(base, 500, nil, started_at)
+          notify_safely(error, context)
+          raise
+        end
+
+        def notify_safely(error, context)
+          if @notifier.respond_to?(:notify_once)
+            @notifier.notify_once(error, context)
+          else
+            @notifier.notify(error, context)
+          end
+        rescue StandardError
+          false
+        end
+
+        def request_capture_context(env)
+          request = request_values(env)
+          {
+            :context => {"request" => request, "trace_id" => trace_id(env)},
+            :parameters => parameters(env),
+            :user => hash_value(env["chronos.user"])
+          }
+        end
+
+        def request_values(env)
+          values = {
+            "method" => env["REQUEST_METHOD"].to_s,
+            "route" => normalized_route(env),
+            "request_id" => request_id(env),
+            "host" => (env["HTTP_HOST"] || env["SERVER_NAME"]).to_s,
+            "path" => env["PATH_INFO"].to_s,
+            "controller" => controller_action(env, "controller"),
+            "action" => controller_action(env, "action")
+          }
+          values["user_agent"] = env["HTTP_USER_AGENT"].to_s if @include_user_agent
+          values
+        end
+
+        def dynamic_request_context(base, status, headers, started_at)
+          request = base[:context]["request"].merge(
+            "status" => status.to_i,
+            "duration_ms" => ((@clock.call - started_at) * 1000.0).round(3),
+            "response_size" => response_size(headers)
+          )
+          {:context => base[:context].merge("request" => request)}
+        end
+
+        def parameters(env)
+          result = {}
+          [env["rack.request.query_hash"], env["action_dispatch.request.query_parameters"],
+           env["action_dispatch.request.path_parameters"], env["chronos.parameters"]].each do |candidate|
+            result.merge!(candidate) if candidate.is_a?(Hash)
+          end
+          result
+        rescue StandardError
+          {}
+        end
+
+        def normalized_route(env)
+          explicit = env["chronos.route"] || env["action_dispatch.route_uri_pattern"]
+          return explicit.to_s unless explicit.to_s.empty?
+
+          env["PATH_INFO"].to_s.split("/").map { |part| dynamic_segment?(part) ? ":id" : part }.join("/")
+        end
+
+        def dynamic_segment?(segment)
+          segment =~ /\A\d+\z/ || segment =~ /\A[0-9a-f]{8}-[0-9a-f-]{27,}\z/i
+        end
+
+        def controller_action(env, key)
+          explicit = env["chronos.#{key}"]
+          paths = env["action_dispatch.request.path_parameters"]
+          explicit || (paths[key] if paths.is_a?(Hash)) || (paths[key.to_sym] if paths.is_a?(Hash))
+        end
+
+        def request_id(env)
+          env["chronos.request_id"] || env["action_dispatch.request_id"] || env["HTTP_X_REQUEST_ID"]
+        end
+
+        def trace_id(env)
+          env["chronos.trace_id"] || SecureRandom.uuid
+        end
+
+        def response_size(headers)
+          return nil unless headers.respond_to?(:each)
+
+          pair = headers.find { |key, _value| key.to_s.casecmp("content-length").zero? }
+          pair ? pair[1].to_i : nil
+        rescue StandardError
+          nil
+        end
+
+        def add_request_breadcrumb(message, context)
+          request = context[:context]["request"]
+          @notifier.add_breadcrumb(
+            :category => "request", :message => message,
+            :metadata => {"method" => request["method"], "route" => request["route"], "status" => request["status"]}
+          )
+        end
+
+        def hash_value(value)
+          value.is_a?(Hash) ? value : {}
+        end
+
+        def monotonic_time
+          Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        rescue StandardError
+          Time.now.to_f
+        end
+      end
+    end
+  end
+end

data/lib/chronos/integrations/rack.rb

@@ -0,0 +1,12 @@
+module Chronos
+  module Integrations
+    # Rack protocol integrations that do not require Rack at gem load time.
+    #
+    # @responsibility Namespace Rack-compatible middleware.
+    # @motivation Permit optional use without adding a runtime Rack dependency.
+    # @limits It does not provide Rails-specific route discovery.
+    # @thread_safety Middleware instances may be shared by concurrent Rack threads.
+    # @compatibility Rack 1.x and 2.x protocol shapes on Ruby 2.2.10 through Ruby 2.6.
+    module Rack; end
+  end
+end

data/lib/chronos/integrations.rb

@@ -0,0 +1,10 @@
+module Chronos
+  # Optional framework entry points kept outside the framework-independent core.
+  #
+  # @responsibility Namespace integration adapters such as Rack middleware.
+  # @motivation Keep framework loading optional for plain Ruby applications.
+  # @limits Integrations may depend only on documented public agent behavior.
+  # @thread_safety Each integration documents its own guarantees.
+  # @compatibility Version 0.5 supports Rack protocol behavior on Ruby 2.2.10 through 2.6.
+  module Integrations; end
+end

data/lib/chronos/ports/context_store.rb

@@ -0,0 +1,22 @@
+module Chronos
+  module Ports
+    # Conceptual storage port for execution-scoped context.
+    #
+    # @responsibility Define get, set, clear, and scoped context behavior.
+    # @motivation Let integrations isolate request state without depending on a thread implementation.
+    # @limits The port does not prescribe thread, fiber, or distributed propagation semantics.
+    # @collaborators Agent and context-store adapters.
+    # @thread_safety Implementations must isolate concurrent executions.
+    # @compatibility Ruby 2.2.10 through Ruby 2.6.
+    # @example
+    #   Chronos::Ports::ContextStore.compatible?(store) #=> true
+    # @errors Compatibility checks never invoke application methods.
+    module ContextStore
+      REQUIRED_METHODS = [:get, :set, :clear, :with_context].freeze
+
+      def self.compatible?(object)
+        REQUIRED_METHODS.all? { |method_name| object.respond_to?(method_name) }
+      end
+    end
+  end
+end