chronos-ruby 0.1.0.pre.2 → 0.3.0.pre.1

data/lib/chronos/core/sanitizer.rb

@@ -0,0 +1,161 @@
+require "digest"
+
+module Chronos
+  module Core
+    # Removes secrets and personal data from event values before serialization.
+    #
+    # @responsibility Recursively redact configured keys and recognized sensitive strings.
+    # @motivation Make privacy protection the default before transport or future persistence.
+    # @limits Detection is conservative and cannot replace an application data-governance review.
+    # @collaborators Configuration::Snapshot and application-provided filters.
+    # @thread_safety Instances are immutable; configured filters must be thread-safe.
+    # @compatibility Ruby 2.2.10 through Ruby 2.6; independent of frameworks.
+    # @example
+    #   sanitizer.call("password" => "secret") #=> {"password"=>"[FILTERED]"}
+    # @errors Unsafe values and failing custom filters become redacted placeholders.
+    # @performance Work is linear in the structurally bounded event tree.
+    class Sanitizer
+      FILTERED = SensitiveValueFilter::FILTERED
+      MAX_DEPTH = 10
+      MAX_KEYS = 100
+      MAX_ITEMS = 100
+      MAX_NODES = 2_000
+
+      def initialize(config)
+        @blocklist_names, @blocklist_patterns = compile_matchers(config.blocklist_keys)
+        @allowlist_names, @allowlist_patterns = compile_matchers(config.allowlist_keys)
+        @hash_names, @hash_patterns = compile_matchers(config.hash_keys)
+        @filters = config.filters
+        @sensitive_value_filter = SensitiveValueFilter.new(config.anonymize_ip)
+        @hash_scope = config.project_id.to_s
+        freeze
+      end
+
+      def call(value)
+        sanitize_value(value, nil, true, 0, :nodes => 0, :seen => {})
+      rescue StandardError
+        FILTERED
+      end
+
+      private
+
+      def sanitize_value(value, key, run_filters, depth, state)
+        state[:nodes] += 1
+        return "<node limit reached>" if state[:nodes] > MAX_NODES
+        return "<maximum depth reached>" if depth >= MAX_DEPTH
+
+        result = sanitize_type(value, depth, state)
+        run_filters && key && !@filters.empty? ? filter_value(key, result, depth, state) : result
+      rescue StandardError
+        FILTERED
+      end
+
+      def sanitize_type(value, depth, state)
+        return sanitize_hash(value, depth, state) if value.is_a?(Hash)
+        return sanitize_array(value, depth, state) if value.is_a?(Array)
+        return @sensitive_value_filter.call(value) if value.is_a?(String)
+
+        value
+      end
+
+      def sanitize_hash(value, depth, state)
+        return "<circular reference>" if state[:seen][value.object_id]
+
+        state[:seen][value.object_id] = true
+        result = {}
+        value.to_a.first(MAX_KEYS).each do |key, child|
+          result[key] = sanitize_hash_value(key, child, depth, state)
+        end
+        state[:seen].delete(value.object_id)
+        result
+      end
+
+      def sanitize_hash_value(key, value, depth, state)
+        return FILTERED if blocked_key?(key) && !allowed_key?(key)
+        return hash_value(value) if hashed_key?(key)
+
+        sanitize_value(value, key, true, depth + 1, state)
+      end
+
+      def sanitize_array(value, depth, state)
+        return "<circular reference>" if state[:seen][value.object_id]
+
+        state[:seen][value.object_id] = true
+        result = value.first(MAX_ITEMS).map do |child|
+          sanitize_value(child, nil, true, depth + 1, state)
+        end
+        state[:seen].delete(value.object_id)
+        result
+      end
+
+      def blocked_key?(key)
+        matches_any?(@blocklist_names, @blocklist_patterns, key, true)
+      end
+
+      def allowed_key?(key)
+        matches_any?(@allowlist_names, @allowlist_patterns, key, false)
+      end
+
+      def hashed_key?(key)
+        matches_any?(@hash_names, @hash_patterns, key, false)
+      end
+
+      def compile_matchers(matchers)
+        names = []
+        patterns = []
+        matchers.each do |matcher|
+          matcher.is_a?(Regexp) ? patterns << matcher : names << normalize_key(matcher)
+        end
+        [names.freeze, patterns.freeze]
+      end
+
+      def matches_any?(names, patterns, key, fallback)
+        candidate = safe_key(key)
+        key_name = normalize_key(candidate)
+        name_match = names.any? { |name| key_name == name || key_name.end_with?("_#{name}") }
+        name_match || patterns.any? { |pattern| pattern =~ candidate }
+      rescue StandardError
+        fallback
+      end
+
+      def normalize_key(value)
+        value.to_s.downcase.gsub(/[^a-z0-9]+/, "_").sub(/\A_+/, "").sub(/_+\z/, "")
+      end
+
+      def safe_key(value)
+        return value if value.is_a?(String)
+        return value.to_s if value.is_a?(Symbol) || value.is_a?(Numeric)
+
+        "<#{safe_class_name(value)}>"
+      rescue StandardError
+        "<unreadable key>"
+      end
+
+      def hash_value(value)
+        scalar = case value
+                 when String, Symbol, Numeric
+                   value.to_s
+                 else
+                   return FILTERED
+                 end
+        digest = Digest::SHA256.hexdigest("chronos:#{@hash_scope}:#{scalar}")
+        "[HASHED_SHA256:#{digest}]"
+      rescue StandardError
+        FILTERED
+      end
+
+      def filter_value(key, value, depth, state)
+        filtered = @filters.inject(value) { |current, filter| filter.call(key, current) }
+        sanitize_value(filtered, nil, false, depth, state)
+      rescue StandardError
+        FILTERED
+      end
+
+      def safe_class_name(value)
+        value.class.name.to_s
+      rescue StandardError
+        "Object"
+      end
+    end
+  end
+end

data/lib/chronos/core/sensitive_value_filter.rb

@@ -0,0 +1,118 @@
+module Chronos
+  module Core
+    # Redacts recognized secret and personal-data patterns inside strings.
+    #
+    # @responsibility Detect bounded sensitive value formats independently of hash-key policy.
+    # @motivation Protect exception messages and allowlisted fields where no sensitive key exists.
+    # @limits Detection is conservative, validates documents and cards, and does not cover every format.
+    # @collaborators Sanitizer.
+    # @thread_safety Immutable after construction and safe to share between capture calls.
+    # @compatibility Ruby 2.2.10 through Ruby 2.6.
+    # @example
+    #   filter.call("person@example.com") #=> "[FILTERED_EMAIL]"
+    # @errors Invalid encodings become a filtered placeholder.
+    # @performance Applies a fixed set of regular expressions to each bounded string.
+    class SensitiveValueFilter
+      FILTERED = "[FILTERED]".freeze
+      FILTERED_EMAIL = "[FILTERED_EMAIL]".freeze
+      FILTERED_DOCUMENT = "[FILTERED_DOCUMENT]".freeze
+      FILTERED_CARD = "[FILTERED_CARD]".freeze
+      FILTERED_JWT = "[FILTERED_JWT]".freeze
+
+      EMAIL_PATTERN = /\b[A-Z0-9._%+\-]+@[A-Z0-9.\-]+\.[A-Z]{2,}\b/i
+      JWT_PATTERN = /\b[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\b/
+      BEARER_PATTERN = /\bBearer\s+[^\s,;]+/i
+      CPF_PATTERN = /\b\d{3}\.?\d{3}\.?\d{3}-?\d{2}\b/
+      CNPJ_PATTERN = %r{\b\d{2}\.?\d{3}\.?\d{3}/?\d{4}-?\d{2}\b}
+      IPV4_PATTERN = /\b(?:\d{1,3}\.){3}\d{1,3}\b/
+      CARD_PATTERN = /\b(?:\d[ -]?){12,18}\d\b/
+
+      def initialize(anonymize_ip)
+        @anonymize_ip = anonymize_ip
+        freeze
+      end
+
+      def call(value)
+        result = safe_string(value)
+        result = result.gsub(BEARER_PATTERN, "Bearer #{FILTERED}") if result =~ BEARER_PATTERN
+        result = result.gsub(JWT_PATTERN, FILTERED_JWT) if result.count(".") >= 2
+        result = result.gsub(EMAIL_PATTERN, FILTERED_EMAIL) if result.include?("@")
+        result = redact_numeric_values(result) if result.count("0-9") >= 11
+        @anonymize_ip && result.count(".") >= 3 ? anonymize_ipv4(result) : result
+      rescue StandardError
+        FILTERED
+      end
+
+      private
+
+      def redact_numeric_values(value)
+        result = redact_documents(value)
+        value.count("0-9") >= 13 ? redact_cards(result) : result
+      end
+
+      def redact_cards(value)
+        value.gsub(CARD_PATTERN) do |candidate|
+          luhn_valid?(candidate) ? FILTERED_CARD : candidate
+        end
+      end
+
+      def redact_documents(value)
+        result = value.gsub(CNPJ_PATTERN) do |candidate|
+          valid_cnpj?(candidate) ? FILTERED_DOCUMENT : candidate
+        end
+        result.gsub(CPF_PATTERN) do |candidate|
+          valid_cpf?(candidate) ? FILTERED_DOCUMENT : candidate
+        end
+      end
+
+      def valid_cpf?(candidate)
+        digits = candidate.gsub(/\D/, "").chars.map(&:to_i)
+        return false if digits.uniq.size == 1
+
+        digits[9] == document_digit(digits.first(9), (2..10).to_a.reverse) &&
+          digits[10] == document_digit(digits.first(10), (2..11).to_a.reverse)
+      end
+
+      def valid_cnpj?(candidate)
+        digits = candidate.gsub(/\D/, "").chars.map(&:to_i)
+        return false if digits.uniq.size == 1
+
+        first_weights = [5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2]
+        second_weights = [6] + first_weights
+        digits[12] == document_digit(digits.first(12), first_weights) &&
+          digits[13] == document_digit(digits.first(13), second_weights)
+      end
+
+      def document_digit(digits, weights)
+        remainder = digits.each_with_index.inject(0) do |sum, (digit, index)|
+          sum + (digit * weights[index])
+        end % 11
+        remainder < 2 ? 0 : 11 - remainder
+      end
+
+      def luhn_valid?(candidate)
+        digits = candidate.gsub(/\D/, "").chars.map(&:to_i)
+        return false unless digits.length.between?(13, 19)
+
+        sum = digits.reverse.each_with_index.inject(0) do |total, (digit, index)|
+          doubled = index.odd? ? digit * 2 : digit
+          total + (doubled > 9 ? doubled - 9 : doubled)
+        end
+        (sum % 10).zero?
+      end
+
+      def anonymize_ipv4(value)
+        value.gsub(IPV4_PATTERN) do |candidate|
+          octets = candidate.split(".").map(&:to_i)
+          octets.all? { |octet| octet.between?(0, 255) } ? "#{octets[0, 3].join('.')}.0" : candidate
+        end
+      end
+
+      def safe_string(value)
+        value.encode("UTF-8", :invalid => :replace, :undef => :replace, :replace => "�")
+      rescue StandardError
+        FILTERED
+      end
+    end
+  end
+end

data/lib/chronos/internal/bounded_queue.rb

@@ -4,7 +4,7 @@ module Chronos
     #
     # @responsibility Accept events up to a limit and count accepted and dropped items.
     # @motivation Prevent telemetry bursts from growing application memory indefinitely.
-    # @limits Version 0.1 drops the newest item when full and does not persist to disk.
+    # @limits Version 0.3 drops the newest item when full and does not persist to disk.
     # @collaborators WorkerPool.
     # @thread_safety Mutex and condition variable protect all mutable state.
     # @compatibility Ruby 2.2.10 through Ruby 2.6 and fork-aware callers.

data/lib/chronos/internal/memory_backlog.rb

@@ -0,0 +1,65 @@
+module Chronos
+  module Internal
+    # Fixed-capacity retry storage for sanitized serialized events.
+    #
+    # @responsibility Retain failed deliveries in memory without unbounded growth.
+    # @motivation Allow later recovery while preserving the host application's memory limit.
+    # @limits It never writes to disk and accepts only SerializedEvent instances.
+    # @collaborators DeliveryPipeline and SerializedEvent.
+    # @thread_safety A mutex protects storage and counters.
+    # @compatibility Ruby 2.2.10 through Ruby 2.6.
+    # @example
+    #   backlog.push(serialized_event)
+    # @errors Invalid event types raise before entering storage.
+    # @performance Push and shift are bounded by the configured capacity.
+    class MemoryBacklog
+      attr_reader :capacity
+
+      def initialize(capacity)
+        unless capacity.is_a?(Integer) && capacity >= 0
+          raise ArgumentError, "capacity must be a non-negative integer"
+        end
+
+        @capacity = capacity
+        @items = []
+        @accepted = 0
+        @dropped = 0
+        @mutex = Mutex.new
+      end
+
+      def push(event)
+        unless event.is_a?(Core::SerializedEvent)
+          raise ArgumentError, "backlog accepts only sanitized serialized events"
+        end
+
+        @mutex.synchronize do
+          if @items.length >= capacity
+            @dropped += 1
+            return false
+          end
+          @items << event
+          @accepted += 1
+          true
+        end
+      end
+
+      def shift
+        @mutex.synchronize { @items.shift }
+      end
+
+      def size
+        @mutex.synchronize { @items.size }
+      end
+
+      def empty?
+        size.zero?
+      end
+
+      def stats
+        @mutex.synchronize do
+          {:size => @items.size, :capacity => capacity, :accepted => @accepted, :dropped => @dropped}
+        end
+      end
+    end
+  end
+end

data/lib/chronos/internal/worker_pool.rb

@@ -4,8 +4,8 @@ module Chronos
     #
     # @responsibility Start workers on first use, deliver events, flush, and shut down predictably.
     # @motivation Keep serialization and network delivery outside the caller's critical path.
-    # @limits Version 0.1 does not retry failed deliveries or persist a backlog.
-    # @collaborators BoundedQueue, Transport, and SafeLogger.
+    # @limits Retry policy belongs to the delivery collaborator.
+    # @collaborators BoundedQueue, DeliveryPipeline, and SafeLogger.
     # @thread_safety Internal state is synchronized and active delivery is counted.
     # @compatibility Ruby 2.2.10 through Ruby 2.6; workers are recreated after fork.
     # @example
@@ -16,9 +16,9 @@ module Chronos
     class WorkerPool
       POLL_INTERVAL = 0.05
 
-      def initialize(queue, transport, worker_count, logger = nil)
+      def initialize(queue, delivery, worker_count, logger = nil)
         @queue = queue
-        @transport = transport
+        @delivery = delivery
         @worker_count = worker_count
         @logger = logger || SafeLogger.new(nil)
         @mutex = Mutex.new
@@ -59,7 +59,6 @@ module Chronos
         flushed = flush_without_reopening(timeout)
         @queue.close
         join_workers(timeout)
-        @transport.close
         flushed
       rescue StandardError => error
         @logger.warn("Chronos worker shutdown failed: #{error.class}")
@@ -87,7 +86,7 @@ module Chronos
 
           increment_active
           begin
-            @transport.send_event(event)
+            @delivery.send_event(event)
           rescue StandardError => error
             @logger.warn("Chronos worker contained #{error.class}")
           ensure

data/lib/chronos/ports/transport.rb

@@ -4,17 +4,18 @@ module Chronos
     #
     # @responsibility Describe delivery outcome and retry classification.
     # @motivation Keep HTTP implementation details outside the application layer.
-    # @limits It does not schedule retries; retry is outside version 0.1.
+    # @limits It classifies outcomes but does not schedule retries.
     # @thread_safety Immutable after construction.
     # @compatibility Ruby 2.2.10 through Ruby 2.6.
     class TransportResult
-      attr_reader :status, :status_code, :retry_after, :error
+      attr_reader :status, :status_code, :retry_after, :error, :remote_configuration
 
       def initialize(status, options = {})
         @status = status
         @status_code = options[:status_code]
         @retry_after = options[:retry_after]
         @error = options[:error]
+        @remote_configuration = options[:remote_configuration]
         freeze
       end
 
@@ -23,7 +24,7 @@ module Chronos
       end
 
       def retryable?
-        [:rate_limited, :server_error, :network_error].include?(status)
+        [:request_timeout, :rate_limited, :server_error, :network_error].include?(status)
       end
     end
 

data/lib/chronos/version.rb

@@ -1,4 +1,4 @@
 module Chronos
   # Current version of the legacy Chronos Ruby agent.
-  VERSION = "0.1.0.pre.2".freeze
+  VERSION = "0.3.0.pre.1".freeze
 end

data/lib/chronos.rb

@@ -11,12 +11,20 @@ require "chronos/core/backtrace_parser"
 require "chronos/core/exception_cause_collector"
 require "chronos/core/runtime_info"
 require "chronos/core/notice_builder"
+require "chronos/core/sensitive_value_filter"
+require "chronos/core/sanitizer"
+require "chronos/core/safe_serializer"
 require "chronos/core/payload_serializer"
 require "chronos/ports/transport"
 require "chronos/internal/safe_logger"
 require "chronos/internal/bounded_queue"
+require "chronos/internal/memory_backlog"
 require "chronos/internal/worker_pool"
 require "chronos/adapters/net_http_transport"
+require "chronos/application/retry_policy"
+require "chronos/application/circuit_breaker"
+require "chronos/application/remote_configuration"
+require "chronos/application/delivery_pipeline"
 require "chronos/application/capture_exception"
 require "chronos/agent"
 
@@ -24,7 +32,7 @@ require "chronos/agent"
 #
 # @responsibility Configure the agent and expose its small lifecycle API.
 # @motivation Give applications a stable entry point while internals evolve.
-# @limits Version 0.1 captures Ruby exceptions only; integrations arrive later.
+# @limits Version 0.3 captures Ruby exceptions manually; integrations arrive later.
 # @collaborators Configuration and Agent.
 # @thread_safety Agent replacement and lookup are protected by a mutex.
 # @compatibility Ruby 2.2.10 through Ruby 2.6.

metadata

@@ -1,11 +1,11 @@
 --- !ruby/object:Gem::Specification
 name: chronos-ruby
 version: !ruby/object:Gem::Version
-  version: 0.1.0.pre.2
+  version: 0.3.0.pre.1
 platform: ruby
 authors:
 - Antonio Jefferson
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
 date: 2026-07-20 00:00:00.000000000 Z
@@ -30,14 +30,20 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '12.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 12.3.3
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '12.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 12.3.3
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -56,16 +62,16 @@ dependencies:
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.47.1
+        version: 0.49.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.47.1
+        version: 0.49.0
 description: Base do cliente Chronos para excecoes, telemetria e observabilidade em
   aplicacoes Ruby legadas.
 email:
@@ -87,6 +93,7 @@ files:
 - docs/adr/ADR-004-bounded-queue.md
 - docs/adr/ADR-005-sanitize-before-backlog.md
 - docs/adr/ADR-006-versioned-event-contract.md
+- docs/adr/ADR-011-bounded-resilience-and-remote-control.md
 - docs/architecture.md
 - docs/compatibility.md
 - docs/configuration.md
@@ -95,6 +102,10 @@ files:
 - docs/modules/async-queue.md
 - docs/modules/configuration.md
 - docs/modules/notice-pipeline.md
+- docs/modules/remote-configuration.md
+- docs/modules/retry-backlog.md
+- docs/modules/sanitization.md
+- docs/modules/serialization.md
 - docs/modules/transport.md
 - docs/performance.md
 - docs/privacy-lgpd.md
@@ -105,6 +116,10 @@ files:
 - lib/chronos/agent.rb
 - lib/chronos/application.rb
 - lib/chronos/application/capture_exception.rb
+- lib/chronos/application/circuit_breaker.rb
+- lib/chronos/application/delivery_pipeline.rb
+- lib/chronos/application/remote_configuration.rb
+- lib/chronos/application/retry_policy.rb
 - lib/chronos/configuration.rb
 - lib/chronos/core.rb
 - lib/chronos/core/backtrace_parser.rb
@@ -113,9 +128,13 @@ files:
 - lib/chronos/core/notice_builder.rb
 - lib/chronos/core/payload_serializer.rb
 - lib/chronos/core/runtime_info.rb
+- lib/chronos/core/safe_serializer.rb
+- lib/chronos/core/sanitizer.rb
+- lib/chronos/core/sensitive_value_filter.rb
 - lib/chronos/errors.rb
 - lib/chronos/internal.rb
 - lib/chronos/internal/bounded_queue.rb
+- lib/chronos/internal/memory_backlog.rb
 - lib/chronos/internal/safe_logger.rb
 - lib/chronos/internal/worker_pool.rb
 - lib/chronos/ports.rb
@@ -131,7 +150,7 @@ metadata:
   homepage_uri: https://github.com/antoniojefferson/chronos-ruby
   source_code_uri: https://github.com/antoniojefferson/chronos-ruby
   changelog_uri: https://github.com/antoniojefferson/chronos-ruby/blob/main/CHANGELOG.md
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -149,8 +168,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 1.3.1
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.4.22
+signing_key:
 specification_version: 4
 summary: Cliente Ruby para captura de eventos do Chronos
 test_files: []