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

data/lib/chronos/configuration.rb

@@ -19,17 +19,64 @@ module Chronos
   #   config.host = 'https://chronos.example.com'
   #   snapshot = config.snapshot
   class Configuration
+    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
+
     ATTRIBUTES = [
       :project_id, :project_key, :host, :environment, :app_version,
       :service_name, :root_directory, :logger, :timeout, :open_timeout,
       :queue_size, :workers, :enabled, :error_notifications,
       :ignored_environments, :proxy, :ssl_verify, :user_agent,
-      :max_payload_size, :gzip
+      :max_payload_size, :gzip, :blocklist_keys, :allowlist_keys,
+      :filters, :hash_keys, :anonymize_ip, :max_retries,
+      :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
     ].freeze
 
     attr_accessor(*ATTRIBUTES)
 
     def initialize
+      initialize_core_defaults
+      initialize_privacy_defaults
+      initialize_resilience_defaults
+    end
+
+    def snapshot
+      errors = validation_errors
+      raise ConfigurationError, errors.join(", ") unless errors.empty?
+
+      Snapshot.new(to_hash)
+    end
+
+    def valid?
+      validation_errors.empty?
+    end
+
+    def validation_errors
+      errors = []
+      if enabled
+        errors << "project_id is required" if blank?(project_id)
+        errors << "project_key is required" if blank?(project_key)
+        errors.concat(host_errors)
+      end
+      errors << "timeout must be greater than zero" unless positive_number?(timeout)
+      errors << "open_timeout must be greater than zero" unless positive_number?(open_timeout)
+      errors << "queue_size must be a positive integer" unless positive_integer?(queue_size)
+      errors << "workers must be a positive integer" unless positive_integer?(workers)
+      errors << "max_payload_size must be a positive integer" unless positive_integer?(max_payload_size)
+      errors.concat(resilience_errors)
+      errors.concat(privacy_errors)
+      errors
+    end
+
+    private
+
+    def initialize_core_defaults
       @project_id = nil
       @project_key = nil
       @host = nil
@@ -52,39 +99,124 @@ module Chronos
       @gzip = false
     end
 
-    def snapshot
-      errors = validation_errors
-      raise ConfigurationError, errors.join(", ") unless errors.empty?
+    def initialize_privacy_defaults
+      @blocklist_keys = DEFAULT_BLOCKLIST_KEYS.dup
+      @allowlist_keys = []
+      @filters = []
+      @hash_keys = []
+      @anonymize_ip = true
+    end
 
-      Snapshot.new(to_hash)
+    def initialize_resilience_defaults
+      @max_retries = 3
+      @retry_base_interval = 0.5
+      @retry_max_interval = 30.0
+      @retry_jitter = 0.25
+      @backlog_size = 100
+      @circuit_failure_threshold = 5
+      @circuit_reset_timeout = 30.0
+      @remote_configuration = true
+      @remote_config_max_bytes = 4096
+      @sampling_rate = 1.0
+      @enabled_event_types = ["exception"]
+      @max_remote_send_interval = 60.0
     end
 
-    def valid?
-      validation_errors.empty?
+    def resilience_errors
+      errors = []
+      errors.concat(retry_errors)
+      errors.concat(backlog_and_circuit_errors)
+      errors.concat(remote_policy_errors)
+      errors
     end
 
-    def validation_errors
+    def retry_errors
       errors = []
-      if enabled
-        errors << "project_id is required" if blank?(project_id)
-        errors << "project_key is required" if blank?(project_key)
-        errors.concat(host_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 << "timeout must be greater than zero" unless positive_number?(timeout)
-      errors << "open_timeout must be greater than zero" unless positive_number?(open_timeout)
-      errors << "queue_size must be a positive integer" unless positive_integer?(queue_size)
-      errors << "workers must be a positive integer" unless positive_integer?(workers)
-      errors << "max_payload_size must be a positive integer" unless positive_integer?(max_payload_size)
+      errors << "retry_jitter must be between zero and one" unless rate?(retry_jitter)
       errors
     end
 
-    private
+    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)
-        value = value.dup if value.is_a?(Array) || value.is_a?(Hash) || value.is_a?(String)
-        values[attribute] = value
+        values[attribute] = deep_copy(value)
+      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
+        value.each_with_object({}) { |(key, child), result| result[deep_copy(key)] = deep_copy(child) }
+      when Array
+        value.map { |child| deep_copy(child) }
+      when String, Regexp
+        value.dup
+      else
+        value
       end
     end
 
@@ -112,6 +244,14 @@ module Chronos
       value.is_a?(Integer) && value > 0
     end
 
+    def non_negative_integer?(value)
+      value.is_a?(Integer) && value >= 0
+    end
+
+    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.
@@ -125,7 +265,7 @@ module Chronos
       def initialize(values)
         ATTRIBUTES.each do |attribute|
           value = values[attribute]
-          value.freeze if value.is_a?(Array) || value.is_a?(Hash) || value.is_a?(String)
+          deep_freeze(value)
           instance_variable_set("@#{attribute}", value)
         end
         freeze
@@ -134,6 +274,23 @@ module Chronos
       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

data/lib/chronos/core/notice.rb

@@ -4,7 +4,7 @@ module Chronos
     #
     # @responsibility Carry exception and diagnostic context through the pipeline.
     # @motivation Keep transport details separate from exception normalization.
-    # @limits It does not sanitize, serialize, enqueue, or send itself.
+    # @limits It does not sanitize, serialize, enqueue, or send itself; raw values live only in memory.
     # @collaborators NoticeBuilder and PayloadSerializer.
     # @thread_safety Immutable after construction and safe to share.
     # @compatibility Ruby 2.2.10 through Ruby 2.6; independent of Rails.

data/lib/chronos/core/payload_serializer.rb

@@ -26,33 +26,32 @@ module Chronos
 
     # Converts a Notice into the versioned Chronos JSON envelope.
     #
-    # @responsibility Normalize values to JSON primitives and enforce size limits.
-    # @motivation Prevent arbitrary application objects or invalid encodings from breaking capture.
-    # @limits Version 0.1 applies structural limits, not the advanced privacy rules from 0.2.
-    # @collaborators Notice and SerializedEvent.
+    # @responsibility Sanitize an event, normalize it to JSON primitives, and enforce size limits.
+    # @motivation Ensure sensitive or unsafe application values never reach transport unchanged.
+    # @limits Detection is bounded and does not replace application-specific data governance.
+    # @collaborators Notice, Sanitizer, SafeSerializer, and SerializedEvent.
     # @thread_safety Stateless apart from immutable configuration.
     # @compatibility Uses the JSON standard library available on Ruby 2.2.10.
     # @example
     #   event = serializer.call(notice)
     #   event.body #=> "{...}"
     # @errors Serialization failures are handled by CaptureException.
-    # @performance Linear in payload size with bounded depth and collection sizes.
+    # @performance Linear in payload size with bounded depth, nodes, and collection sizes.
     class PayloadSerializer
-      MAX_DEPTH = 10
-      MAX_KEYS = 100
-      MAX_ITEMS = 100
-      MAX_STRING_BYTES = 8192
-
-      def initialize(config, clock = nil)
+      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 }
       end
 
       def call(notice)
-        envelope = build_envelope(notice)
+        envelope = @safe_serializer.call(@sanitizer.call(build_envelope(notice)))
         body = JSON.generate(envelope)
-        body = JSON.generate(compact_envelope(envelope)) if body.bytesize > @config.max_payload_size
-        raise Error, "event exceeds max_payload_size" if body.bytesize > @config.max_payload_size
+        limit = @max_payload_size.call
+        body = JSON.generate(compact_envelope(envelope)) if body.bytesize > limit
+        raise Error, "event exceeds max_payload_size" if body.bytesize > limit
 
         SerializedEvent.new(notice.event_id, body)
       end
@@ -66,44 +65,44 @@ module Chronos
           "event_type" => "exception",
           "occurred_at" => notice.timestamp,
           "sent_at" => @clock.call.utc.iso8601(6),
-          "project_key" => safe_string(@config.project_id),
-          "environment" => safe_string(notice.environment),
+          "project_key" => @config.project_id,
+          "environment" => notice.environment,
           "service" => {
-            "name" => safe_string(@config.service_name),
-            "version" => safe_string(@config.app_version),
-            "instance_id" => safe_string(notice.host)
+            "name" => @config.service_name,
+            "version" => @config.app_version,
+            "instance_id" => notice.host
           },
-          "runtime" => normalize(notice.runtime, 0),
-          "context" => normalize(notice.context, 0),
+          "runtime" => notice.runtime,
+          "context" => notice.context,
           "payload" => payload(notice)
         }
       end
 
       def payload(notice)
-        normalize({
-                    "exception" => {
-                      "class" => notice.exception_class,
-                      "message" => notice.message,
-                      "backtrace" => notice.backtrace,
-                      "causes" => notice.causes
-                    },
-                    "severity" => notice.severity,
-                    "parameters" => notice.parameters,
-                    "session" => notice.session,
-                    "user" => notice.user,
-                    "versions" => notice.versions,
-                    "host" => notice.host,
-                    "process" => notice.process,
-                    "thread" => notice.thread,
-                    "tags" => notice.tags,
-                    "fingerprint" => notice.fingerprint
-                  }, 0)
+        {
+          "exception" => {
+            "class" => notice.exception_class,
+            "message" => notice.message,
+            "backtrace" => notice.backtrace,
+            "causes" => notice.causes
+          },
+          "severity" => notice.severity,
+          "parameters" => notice.parameters,
+          "session" => notice.session,
+          "user" => notice.user,
+          "versions" => notice.versions,
+          "host" => notice.host,
+          "process" => notice.process,
+          "thread" => notice.thread,
+          "tags" => notice.tags,
+          "fingerprint" => notice.fingerprint
+        }
       end
 
       def compact_envelope(envelope)
         payload = envelope["payload"]
         exception = payload["exception"]
-        exception["message"] = truncate_string(exception["message"], 1024)
+        exception["message"] = @safe_serializer.call(exception["message"], :max_string_bytes => 1024)
         exception["backtrace"] = Array(exception["backtrace"]).first(20)
         payload["parameters"] = {"_truncated" => true}
         payload["session"] = {"_truncated" => true}
@@ -111,55 +110,6 @@ module Chronos
         envelope["context"] = {"_truncated" => true}
         envelope
       end
-
-      def normalize(value, depth)
-        return "<maximum depth reached>" if depth >= MAX_DEPTH
-
-        case value
-        when nil, true, false, Integer
-          value
-        when Float
-          value.finite? ? value : value.to_s
-        when String, Symbol
-          truncate_string(safe_string(value), MAX_STRING_BYTES)
-        when Array
-          value.first(MAX_ITEMS).map { |child| normalize(child, depth + 1) }
-        when Hash
-          normalize_hash(value, depth)
-        else
-          "<#{safe_class_name(value)}>"
-        end
-      rescue StandardError
-        "<unserializable value>"
-      end
-
-      def normalize_hash(value, depth)
-        result = {}
-        value.to_a.first(MAX_KEYS).each do |key, child|
-          result[truncate_string(safe_string(key), 256)] = normalize(child, depth + 1)
-        end
-        result
-      end
-
-      def safe_string(value)
-        return nil if value.nil?
-
-        value.to_s.encode("UTF-8", :invalid => :replace, :undef => :replace, :replace => "�")
-      rescue StandardError
-        "<unreadable value>"
-      end
-
-      def truncate_string(value, limit)
-        return value if value.nil? || value.bytesize <= limit
-
-        value.byteslice(0, limit).to_s.encode("UTF-8", :invalid => :replace, :undef => :replace, :replace => "�") + "…"
-      end
-
-      def safe_class_name(value)
-        value.class.name.to_s
-      rescue StandardError
-        "Object"
-      end
     end
   end
 end

data/lib/chronos/core/runtime_info.rb

@@ -22,7 +22,7 @@ module Chronos
           },
           :host => safe_hostname,
           :process => {"pid" => Process.pid},
-          :thread => {"id" => Thread.current.object_id.to_s}
+          :thread => {"id" => "0x#{Thread.current.object_id.to_s(16)}"}
         }
       end
 

data/lib/chronos/core/safe_serializer.rb

@@ -0,0 +1,119 @@
+module Chronos
+  module Core
+    # Converts bounded Ruby structures to values accepted by JSON.generate.
+    #
+    # @responsibility Normalize only JSON primitives while enforcing structural budgets.
+    # @motivation Prevent application objects, cycles, or invalid encoding from breaking capture.
+    # @limits It does not redact secrets; Sanitizer must run before this component.
+    # @collaborators PayloadSerializer.
+    # @thread_safety Each call owns its traversal state and can run concurrently.
+    # @compatibility Ruby 2.2.10 through Ruby 2.6.
+    # @example
+    #   serializer.call(:status => :ok) #=> {"status"=>"ok"}
+    # @errors Individual unreadable values become bounded placeholders.
+    # @performance Depth, nodes, keys, items, and string bytes are bounded.
+    class SafeSerializer
+      DEFAULTS = {
+        :max_depth => 10,
+        :max_keys => 100,
+        :max_items => 100,
+        :max_string_bytes => 8192,
+        :max_nodes => 2_000
+      }.freeze
+
+      def initialize(options = {})
+        @options = DEFAULTS.merge(options).freeze
+      end
+
+      def call(value, overrides = {})
+        settings = @options.merge(overrides)
+        normalize(value, 0, {}, {:nodes => 0}, settings)
+      rescue StandardError
+        "<unserializable value>"
+      end
+
+      private
+
+      def normalize(value, depth, seen, state, settings)
+        state[:nodes] += 1
+        return "<node limit reached>" if state[:nodes] > settings[:max_nodes]
+        return "<maximum depth reached>" if depth >= settings[:max_depth]
+
+        return normalize_array(value, depth, seen, state, settings) if value.is_a?(Array)
+        return normalize_hash(value, depth, seen, state, settings) if value.is_a?(Hash)
+
+        normalize_scalar(value, settings)
+      rescue StandardError
+        "<unserializable value>"
+      end
+
+      def normalize_scalar(value, settings)
+        case value
+        when nil, true, false, Integer
+          value
+        when Float
+          value.finite? ? value : value.to_s
+        when String
+          truncate_string(safe_string(value), settings[:max_string_bytes])
+        when Symbol
+          truncate_string(value.to_s, settings[:max_string_bytes])
+        else
+          "<#{safe_class_name(value)}>"
+        end
+      end
+
+      def normalize_array(value, depth, seen, state, settings)
+        return "<circular reference>" if seen[value.object_id]
+
+        seen[value.object_id] = true
+        result = value.first(settings[:max_items]).map do |child|
+          normalize(child, depth + 1, seen, state, settings)
+        end
+        seen.delete(value.object_id)
+        result
+      end
+
+      def normalize_hash(value, depth, seen, state, settings)
+        return "<circular reference>" if seen[value.object_id]
+
+        seen[value.object_id] = true
+        result = {}
+        value.to_a.first(settings[:max_keys]).each do |key, child|
+          result[safe_key(key)] = normalize(child, depth + 1, seen, state, settings)
+        end
+        seen.delete(value.object_id)
+        result
+      end
+
+      def safe_key(value)
+        string = if value.is_a?(String) || value.is_a?(Symbol) || value.is_a?(Numeric)
+                   value.to_s
+                 else
+                   "<#{safe_class_name(value)}>"
+                 end
+        truncate_string(safe_string(string), 256)
+      rescue StandardError
+        "<unreadable key>"
+      end
+
+      def safe_string(value)
+        value.encode("UTF-8", :invalid => :replace, :undef => :replace, :replace => "�")
+      rescue StandardError
+        "<unreadable value>"
+      end
+
+      def truncate_string(value, limit)
+        return value if value.bytesize <= limit
+
+        prefix = value.byteslice(0, limit).to_s
+        safe_string(prefix) + "…"
+      end
+
+      def safe_class_name(value)
+        value.class.name.to_s
+      rescue StandardError
+        "Object"
+      end
+    end
+  end
+end