chronos-ruby 0.1.0.pre.2

data/lib/chronos/internal/worker_pool.rb

@@ -0,0 +1,155 @@
+module Chronos
+  module Internal
+    # Fixed-size, lazy worker pool that drains a BoundedQueue.
+    #
+    # @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.
+    # @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
+    #   pool.enqueue(event)
+    #   pool.flush(2.0)
+    # @errors Worker errors are diagnosed and contained inside the pool.
+    # @performance Creates a fixed number of threads only after the first accepted event.
+    class WorkerPool
+      POLL_INTERVAL = 0.05
+
+      def initialize(queue, transport, worker_count, logger = nil)
+        @queue = queue
+        @transport = transport
+        @worker_count = worker_count
+        @logger = logger || SafeLogger.new(nil)
+        @mutex = Mutex.new
+        @threads = []
+        @active = 0
+        @closed = false
+        @pid = Process.pid
+      end
+
+      def enqueue(event)
+        prepare_after_fork
+        return false if closed?
+
+        accepted = @queue.push(event)
+        ensure_started if accepted
+        accepted
+      end
+
+      def flush(timeout)
+        prepare_after_fork
+        ensure_started unless @queue.empty?
+        deadline = monotonic_time + timeout.to_f
+        loop do
+          return true if @queue.empty? && active_count.zero?
+          return false if monotonic_time >= deadline
+          sleep(POLL_INTERVAL)
+        end
+      end
+
+      def close(timeout)
+        already_closed = @mutex.synchronize do
+          was_closed = @closed
+          @closed = true
+          was_closed
+        end
+        return true if already_closed
+
+        flushed = flush_without_reopening(timeout)
+        @queue.close
+        join_workers(timeout)
+        @transport.close
+        flushed
+      rescue StandardError => error
+        @logger.warn("Chronos worker shutdown failed: #{error.class}")
+        false
+      end
+
+      def started?
+        @mutex.synchronize { !@threads.empty? }
+      end
+
+      private
+
+      def ensure_started
+        @mutex.synchronize do
+          return if @closed || !@threads.empty?
+          @worker_count.times { @threads << Thread.new { work_loop } }
+        end
+      end
+
+      def work_loop
+        loop do
+          event = @queue.pop(POLL_INTERVAL)
+          break if event.nil? && @queue.closed?
+          next unless event
+
+          increment_active
+          begin
+            @transport.send_event(event)
+          rescue StandardError => error
+            @logger.warn("Chronos worker contained #{error.class}")
+          ensure
+            decrement_active
+          end
+        end
+      rescue StandardError => error
+        @logger.warn("Chronos worker stopped after #{error.class}")
+      end
+
+      def prepare_after_fork
+        return if @pid == Process.pid
+
+        @mutex.synchronize do
+          @pid = Process.pid
+          @threads = []
+          @active = 0
+        end
+      end
+
+      def flush_without_reopening(timeout)
+        deadline = monotonic_time + timeout.to_f
+        loop do
+          return true if @queue.empty? && active_count.zero?
+          return false if monotonic_time >= deadline
+          sleep(POLL_INTERVAL)
+        end
+      end
+
+      def join_workers(timeout)
+        deadline = monotonic_time + timeout.to_f
+        threads = @mutex.synchronize { @threads.dup }
+        threads.each do |thread|
+          remaining = deadline - monotonic_time
+          thread.join(remaining) if remaining > 0
+          thread.kill if thread.alive?
+        end
+      end
+
+      def increment_active
+        @mutex.synchronize { @active += 1 }
+      end
+
+      def decrement_active
+        @mutex.synchronize { @active -= 1 }
+      end
+
+      def active_count
+        @mutex.synchronize { @active }
+      end
+
+      def closed?
+        @mutex.synchronize { @closed }
+      end
+
+      def monotonic_time
+        if Process.respond_to?(:clock_gettime) && defined?(Process::CLOCK_MONOTONIC)
+          Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        else
+          Time.now.to_f
+        end
+      end
+    end
+  end
+end

data/lib/chronos/internal.rb

@@ -0,0 +1,10 @@
+module Chronos
+  # Private runtime infrastructure used by the public agent.
+  #
+  # @responsibility Host bounded concurrency and defensive diagnostics.
+  # @motivation Keep lifecycle mechanisms outside the domain.
+  # @limits Constants under Internal are not part of the stable public API.
+  # @thread_safety Mutable components synchronize their own state.
+  # @compatibility Ruby 2.2.10 through Ruby 2.6.
+  module Internal; end
+end

data/lib/chronos/ports/transport.rb

@@ -0,0 +1,45 @@
+module Chronos
+  module Ports
+    # Result returned by transport adapters instead of raising into the application.
+    #
+    # @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.
+    # @thread_safety Immutable after construction.
+    # @compatibility Ruby 2.2.10 through Ruby 2.6.
+    class TransportResult
+      attr_reader :status, :status_code, :retry_after, :error
+
+      def initialize(status, options = {})
+        @status = status
+        @status_code = options[:status_code]
+        @retry_after = options[:retry_after]
+        @error = options[:error]
+        freeze
+      end
+
+      def success?
+        status == :success
+      end
+
+      def retryable?
+        [:rate_limited, :server_error, :network_error].include?(status)
+      end
+    end
+
+    # Conceptual transport port implemented by delivery adapters.
+    #
+    # @responsibility Define send_event, send_batch, healthy?, and close behavior.
+    # @motivation Let capture code depend on a stable boundary instead of Net::HTTP.
+    # @limits Ruby does not enforce this interface; adapters are verified by contract tests.
+    # @thread_safety Implementations must document their own synchronization.
+    # @compatibility Ruby 2.2.10 through Ruby 2.6.
+    module Transport
+      REQUIRED_METHODS = [:send_event, :send_batch, :healthy?, :close].freeze
+
+      def self.compatible?(object)
+        REQUIRED_METHODS.all? { |method_name| object.respond_to?(method_name) }
+      end
+    end
+  end
+end

data/lib/chronos/ports.rb

@@ -0,0 +1,10 @@
+module Chronos
+  # Stable boundaries implemented by infrastructure adapters.
+  #
+  # @responsibility Define the behavior expected from external collaborators.
+  # @motivation Apply dependency inversion to delivery infrastructure.
+  # @limits Interfaces are verified by behavior because Ruby has no interface keyword.
+  # @thread_safety Each adapter documents its own guarantees.
+  # @compatibility Ruby 2.2.10 through Ruby 2.6.
+  module Ports; end
+end

data/lib/chronos/ruby/version.rb

@@ -0,0 +1 @@
+require "chronos/version"

data/lib/chronos/ruby.rb

@@ -0,0 +1 @@
+require "chronos"

data/lib/chronos/version.rb

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

data/lib/chronos.rb

@@ -0,0 +1,98 @@
+require "chronos/version"
+require "chronos/errors"
+require "chronos/configuration"
+require "chronos/core"
+require "chronos/application"
+require "chronos/ports"
+require "chronos/adapters"
+require "chronos/internal"
+require "chronos/core/notice"
+require "chronos/core/backtrace_parser"
+require "chronos/core/exception_cause_collector"
+require "chronos/core/runtime_info"
+require "chronos/core/notice_builder"
+require "chronos/core/payload_serializer"
+require "chronos/ports/transport"
+require "chronos/internal/safe_logger"
+require "chronos/internal/bounded_queue"
+require "chronos/internal/worker_pool"
+require "chronos/adapters/net_http_transport"
+require "chronos/application/capture_exception"
+require "chronos/agent"
+
+# Framework-independent public facade for the Chronos Ruby 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.
+# @collaborators Configuration and Agent.
+# @thread_safety Agent replacement and lookup are protected by a mutex.
+# @compatibility Ruby 2.2.10 through Ruby 2.6.
+# @example
+#   Chronos.configure do |config|
+#     config.project_id = "project-id"
+#     config.project_key = "project-key"
+#     config.host = "https://chronos.example.com"
+#   end
+#   Chronos.notify(RuntimeError.new("failed"))
+module Chronos
+  @mutex = Mutex.new
+  @agent = nil
+
+  class << self
+    def configure
+      configuration = Configuration.new
+      yield configuration if block_given?
+      agent = Agent.new(configuration.snapshot)
+      previous = nil
+      @mutex.synchronize do
+        previous = @agent
+        @agent = agent
+      end
+      previous.close if previous
+      configuration
+    end
+
+    def notify(exception, context = {})
+      agent = current_agent
+      agent ? agent.notify(exception, context) : false
+    rescue StandardError
+      false
+    end
+
+    def notify_sync(exception, context = {})
+      agent = current_agent
+      agent ? agent.notify_sync(exception, context) : false
+    rescue StandardError
+      false
+    end
+
+    def configured?
+      !current_agent.nil?
+    end
+
+    def flush(timeout = Agent::DEFAULT_FLUSH_TIMEOUT)
+      agent = current_agent
+      agent ? agent.flush(timeout) : true
+    rescue StandardError
+      false
+    end
+
+    def close(timeout = Agent::DEFAULT_FLUSH_TIMEOUT)
+      agent = @mutex.synchronize do
+        current = @agent
+        @agent = nil
+        current
+      end
+      agent ? agent.close(timeout) : true
+    rescue StandardError
+      false
+    end
+
+    private
+
+    def current_agent
+      @mutex.synchronize { @agent }
+    end
+  end
+end

metadata

@@ -0,0 +1,156 @@
+--- !ruby/object:Gem::Specification
+name: chronos-ruby
+version: !ruby/object:Gem::Version
+  version: 0.1.0.pre.2
+platform: ruby
+authors:
+- Antonio Jefferson
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2026-07-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.17'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.17'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.47.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.47.1
+description: Base do cliente Chronos para excecoes, telemetria e observabilidade em
+  aplicacoes Ruby legadas.
+email:
+- antoniojeferson96@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- CONTRIBUTING.md
+- LICENSE.txt
+- README.md
+- SECURITY.md
+- contracts/event-v1.schema.json
+- docs/adr/ADR-001-core-and-integrations.md
+- docs/adr/ADR-002-version-lines.md
+- docs/adr/ADR-003-net-http-legacy-transport.md
+- docs/adr/ADR-004-bounded-queue.md
+- docs/adr/ADR-005-sanitize-before-backlog.md
+- docs/adr/ADR-006-versioned-event-contract.md
+- docs/architecture.md
+- docs/compatibility.md
+- docs/configuration.md
+- docs/data-collected.md
+- docs/examples/plain-ruby.md
+- docs/modules/async-queue.md
+- docs/modules/configuration.md
+- docs/modules/notice-pipeline.md
+- docs/modules/transport.md
+- docs/performance.md
+- docs/privacy-lgpd.md
+- docs/troubleshooting.md
+- lib/chronos.rb
+- lib/chronos/adapters.rb
+- lib/chronos/adapters/net_http_transport.rb
+- lib/chronos/agent.rb
+- lib/chronos/application.rb
+- lib/chronos/application/capture_exception.rb
+- lib/chronos/configuration.rb
+- lib/chronos/core.rb
+- lib/chronos/core/backtrace_parser.rb
+- lib/chronos/core/exception_cause_collector.rb
+- lib/chronos/core/notice.rb
+- lib/chronos/core/notice_builder.rb
+- lib/chronos/core/payload_serializer.rb
+- lib/chronos/core/runtime_info.rb
+- lib/chronos/errors.rb
+- lib/chronos/internal.rb
+- lib/chronos/internal/bounded_queue.rb
+- lib/chronos/internal/safe_logger.rb
+- lib/chronos/internal/worker_pool.rb
+- lib/chronos/ports.rb
+- lib/chronos/ports/transport.rb
+- lib/chronos/ruby.rb
+- lib/chronos/ruby/version.rb
+- lib/chronos/version.rb
+homepage: https://github.com/antoniojefferson/chronos-ruby
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  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: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.2.10
+  - - "<"
+    - !ruby/object:Gem::Version
+      version: '2.7'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Cliente Ruby para captura de eventos do Chronos
+test_files: []