tobox 0.1.0

data/lib/tobox/plugins/sentry.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module Tobox
+  module Plugins
+    module Sentry
+      class Configuration
+        # Set this option to true if you want Sentry to only capture the last job
+        # retry if it fails.
+        attr_accessor :report_after_retries
+
+        def initialize
+          @report_after_retries = false
+        end
+      end
+
+      class EventHandler
+        TOBOX_NAME = "tobox"
+
+        def initialize(config)
+          @config = config
+          @db_table = @config[:table]
+          @db_scheme = URI(@config[:database_uri]).scheme if @config[:database_uri]
+          @max_attempts = @config[:max_attempts]
+        end
+
+        def on_start(event)
+          return unless ::Sentry.initialized?
+
+          ::Sentry.clone_hub_to_current_thread
+
+          scope = ::Sentry.get_current_scope
+
+          scope.set_contexts(
+            id: event[:id],
+            type: event[:type],
+            attempts: event[:attempts],
+            created_at: event[:created_at],
+            run_at: event[:run_at],
+            last_error: event[:last_error]&.byteslice(0..1000),
+            version: Tobox::VERSION,
+            db_adapter: @db_scheme
+          )
+          scope.set_tags(
+            outbox: @db_table,
+            event_id: event[:id],
+            event_type: event[:type]
+          )
+
+          scope.set_transaction_name("#{TOBOX_NAME}/#{event[:type]}") unless scope.transaction_name
+
+          transaction = start_transaction(scope.transaction_name, event[:metadata].to_h["sentry_trace"])
+
+          return unless transaction
+
+          scope.set_span(transaction)
+
+          # good for thread pool, good for fiber pool
+          store_transaction(event, transaction)
+        end
+
+        def on_finish(event)
+          return unless ::Sentry.initialized?
+
+          transaction = retrieve_transaction(event)
+
+          return unless transaction
+
+          finish_transaction(transaction, 200)
+
+          scope = ::Sentry.get_current_scope
+          scope.clear
+        end
+
+        def on_error(event, error)
+          return unless ::Sentry.initialized?
+
+          transaction = retrieve_transaction(event)
+
+          return unless transaction
+
+          capture_exception(event, error)
+
+          finish_transaction(transaction, 500)
+        end
+
+        private
+
+        def start_transaction(transaction_name, sentry_trace)
+          options = { name: transaction_name, op: "tobox" }
+          transaction = ::Sentry::Transaction.from_sentry_trace(sentry_trace, **options) if sentry_trace
+          ::Sentry.start_transaction(transaction: transaction, **options)
+        end
+
+        def finish_transaction(transaction, status)
+          transaction.set_http_status(status)
+          transaction.finish
+        end
+
+        def store_transaction(event, transaction)
+          store = (Thread.current[:tobox_sentry_transactions] ||= {})
+
+          store[event[:id]] = transaction
+        end
+
+        def retrieve_transaction(event)
+          return unless (store = Thread.current[:tobox_sentry_transactions])
+
+          store.delete(event[:id])
+        end
+
+        def capture_exception(event, error)
+          return unless ::Sentry.configuration.tobox.report_after_retries && event[:attempts] >= @max_attempts
+
+          ::Sentry.capture_exception(
+            error,
+            hint: { background: false }
+          )
+        end
+      end
+
+      class << self
+        def load_dependencies(*)
+          require "uri"
+          require "sentry-ruby"
+        end
+
+        def configure(config)
+          event_handler = EventHandler.new(config)
+          config.on_before_event(&event_handler.method(:on_start))
+          config.on_after_event(&event_handler.method(:on_finish))
+          config.on_error_event(&event_handler.method(:on_error))
+
+          ::Sentry::Configuration.attr_reader(:tobox)
+          ::Sentry::Configuration.add_post_initialization_callback do
+            @tobox = Plugins::Sentry::Configuration.new
+          end
+        end
+      end
+    end
+
+    register_plugin :sentry, Sentry
+  end
+end

data/lib/tobox/plugins/zeitwerk.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Tobox
+  module Plugins
+    module Zeitwerk
+      module ConfigurationMethods
+        def zeitwerk_loader(loader = nil, &blk)
+          if loader
+            @zeitwerk_loader = loader
+          elsif blk
+            @zeitwerk_loader ||= ::Zeitwerk::Loader.new
+            yield(@zeitwerk_loader)
+          elsif !(loader || blk)
+            @zeitwerk_loader
+          end
+        end
+
+        def freeze
+          loader = @zeitwerk_loader
+
+          return super unless loader
+
+          if @config[:environment] == "production"
+            loader.setup
+            ::Zeitwerk::Loader.eager_load_all
+          else
+            loader.enable_reloading
+            loader.setup
+          end
+
+          super
+        end
+      end
+
+      class << self
+        def load_dependencies(*)
+          require "zeitwerk"
+        end
+
+        def configure(config)
+          loader = config.zeitwerk_loader
+
+          return unless loader
+
+          config.on_before_event { |*| loader.reload }
+        end
+      end
+    end
+
+    register_plugin :zeitwerk, Zeitwerk
+  end
+end

data/lib/tobox/pool/fiber_pool.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "timeout"
+require "fiber_scheduler"
+
+module Tobox
+  class FiberPool < Pool
+    class KillError < Interrupt; end
+
+    def initialize(_configuration)
+      Sequel.extension(:fiber_concurrency)
+      super
+      @error_handlers = Array(@configuration.lifecycle_events[:error])
+    end
+
+    def start
+      @fiber_thread = Thread.start do
+        Thread.current.name = "tobox-fibers-thread"
+
+        FiberScheduler do
+          @workers.each_with_index do |wk, _idx|
+            Fiber.schedule do
+              wk.work
+            rescue KillError
+              # noop
+            rescue Exception => e # rubocop:disable Lint/RescueException
+              @error_handlers.each { |hd| hd.call(:tobox_error, e) }
+              raise e
+            end
+          end
+        end
+      end
+    end
+
+    def stop
+      shutdown_timeout = @configuration[:shutdown_timeout]
+
+      super
+
+      begin
+        Timeout.timeout(shutdown_timeout) { @fiber_thread.value }
+      rescue Timeout::Error
+        # hard exit
+        @fiber_thread.raise(KillError)
+        @fiber_thread.value
+      end
+    end
+  end
+end

data/lib/tobox/pool/threaded_pool.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Tobox
+  class ThreadedPool < Pool
+    class KillError < Interrupt; end
+
+    def initialize(_configuration)
+      @threads = []
+      super
+      @error_handlers = Array(@configuration.lifecycle_events[:error])
+    end
+
+    def start
+      @workers.each_with_index do |wk, idx|
+        th = Thread.start do
+          Thread.current.name = "tobox-worker-#{idx}"
+
+          begin
+            wk.work
+          rescue KillError
+            # noop
+          rescue Exception => e # rubocop:disable Lint/RescueException
+            @error_handlers.each { |hd| hd.call(:tobox_error, e) }
+            raise e
+          end
+
+          @threads.delete(Thread.current)
+        end
+        @threads << th
+      end
+    end
+
+    def stop
+      shutdown_timeout = @configuration[:shutdown_timeout]
+
+      deadline = Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+
+      super
+      Thread.pass # let workers finish
+
+      # soft exit
+      while Process.clock_gettime(::Process::CLOCK_MONOTONIC) - deadline < shutdown_timeout
+        return if @threads.empty?
+
+        sleep 0.5
+      end
+
+      # hard exit
+      @threads.each { |th| th.raise(KillError) }
+      while (th = @threads.pop)
+        th.value # waits
+      end
+    end
+  end
+end

data/lib/tobox/pool.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Tobox
+  class Pool
+    def initialize(configuration)
+      @configuration = configuration
+      @num_workers = configuration[:concurrency]
+      @workers = Array.new(@num_workers) { Worker.new(configuration) }
+      start
+    end
+
+    def stop
+      @workers.each(&:finish!)
+    end
+  end
+
+  autoload :ThreadedPool, File.join(__dir__, "pool", "threaded_pool")
+  autoload :FiberPool, File.join(__dir__, "pool", "fiber_pool")
+end

data/lib/tobox/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Tobox
+  VERSION = "0.1.0"
+end

data/lib/tobox/worker.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Tobox
+  class Worker
+    def initialize(configuration)
+      @wait_for_events_delay = configuration[:wait_for_events_delay]
+      @handlers = configuration.handlers || {}
+      @fetcher = Fetcher.new(configuration)
+      @finished = false
+
+      return unless (message_to_arguments = configuration.arguments_handler)
+
+      define_singleton_method(:message_to_arguments, &message_to_arguments)
+    end
+
+    def finish!
+      @finished = true
+    end
+
+    def work
+      do_work until @finished
+    end
+
+    private
+
+    def do_work
+      return if @finished
+
+      sum_fetched_events = @fetcher.fetch_events do |event|
+        event_type = event[:type].to_sym
+        args = message_to_arguments(event)
+
+        if @handlers.key?(event_type)
+          @handlers[event_type].each do |handler|
+            handler.call(args)
+          end
+        end
+      end
+
+      return if @finished
+
+      sleep(@wait_for_events_delay) if sum_fetched_events.zero?
+    end
+
+    def message_to_arguments(event)
+      event
+    end
+  end
+end

data/lib/tobox.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "sequel"
+
+require_relative "tobox/version"
+
+require "mutex_m"
+
+module Tobox
+  class Error < StandardError; end
+
+  module Plugins
+    @plugins = {}
+    @plugins.extend(Mutex_m)
+
+    # Loads a plugin based on a name. If the plugin hasn't been loaded, tries to load
+    # it from the load path under "httpx/plugins/" directory.
+    #
+    def self.load_plugin(name)
+      h = @plugins
+      unless (plugin = h.synchronize { h[name] })
+        require "tobox/plugins/#{name}"
+        raise "Plugin #{name} hasn't been registered" unless (plugin = h.synchronize { h[name] })
+      end
+      plugin
+    end
+
+    # Registers a plugin (+mod+) in the central store indexed by +name+.
+    #
+    def self.register_plugin(name, mod)
+      h = @plugins
+      h.synchronize { h[name] = mod }
+    end
+  end
+end
+
+require_relative "tobox/configuration"
+require_relative "tobox/fetcher"
+require_relative "tobox/worker"
+require_relative "tobox/pool"
+require_relative "tobox/application"

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification
+name: tobox
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- HoneyryderChuck
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2022-09-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sequel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.35'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.35'
+description: Transactional outbox pattern implementation in ruby
+email:
+- cardoso_tiago@hotmail.com
+executables:
+- tobox
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- exe/tobox
+- lib/tobox.rb
+- lib/tobox/application.rb
+- lib/tobox/cli.rb
+- lib/tobox/configuration.rb
+- lib/tobox/fetcher.rb
+- lib/tobox/plugins/datadog.rb
+- lib/tobox/plugins/datadog/configuration.rb
+- lib/tobox/plugins/datadog/integration.rb
+- lib/tobox/plugins/datadog/patcher.rb
+- lib/tobox/plugins/sentry.rb
+- lib/tobox/plugins/zeitwerk.rb
+- lib/tobox/pool.rb
+- lib/tobox/pool/fiber_pool.rb
+- lib/tobox/pool/threaded_pool.rb
+- lib/tobox/version.rb
+- lib/tobox/worker.rb
+homepage: https://gitlab.com/honeyryderchuck/tobox
+licenses: []
+metadata:
+  homepage_uri: https://gitlab.com/honeyryderchuck/tobox
+  allowed_push_host: https://rubygems.org
+  source_code_uri: https://gitlab.com/honeyryderchuck/tobox
+  bug_tracker_uri: https://gitlab.com/honeyryderchuck/tobox/issues
+  documentation_uri: https://gitlab.com/honeyryderchuck/tobox
+  changelog_uri: https://gitlab.com/honeyryderchuck/tobox/-/blob/master/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.7
+signing_key:
+specification_version: 4
+summary: Transactional outbox pattern implementation in ruby
+test_files: []