upfluence-utils 0.12.20 → 0.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c1153c2254907a24cfdf4158ecba796e11c64d33c16e1c768dc1d8bbbb373ffd
-  data.tar.gz: 18af6544045d8f1d8a9378be19e6e09daacc6ed5102b8a8a4af60af7516f1ff1
+  metadata.gz: a28871a5df31d6b75af4475a60543e0810fd0094dea6d724afbd848a71607761
+  data.tar.gz: ac59cc58a69b360c825e79abec46da346eff81e43ca87e9d4243c49fc89dfb3e
 SHA512:
-  metadata.gz: ac346ac44165b16a01c5f3e0ffd4a32bc1c78337d50b033b422cf23dcd6b3662cade01d40b51ac242331cf629f94c8f8bc442cc79e6690d302160942beacd28c
-  data.tar.gz: 446c23bf81c04fead4cc60a6b70c8729372250654a59c3deedccc40e4c59c2c1c34ff181818a445a6115d4042d94231f48633ff5d4514f37979a63aedc3afa42
+  metadata.gz: bdc88bee6a3b265e0edebd6697f7ce7f350c83f5746c285e02057ee89e2a5e52ce215ff35e0e5e6de2b36db0722d3fa96e5955a627610d02acfcfb29f32ced9a
+  data.tar.gz: 420de9021031ed18c35dd8bcca08892a6db87a4e1aaa4efb4495c338fbe66c157103919e6ae4eedf263a1ec8e50aa29bf20b08d9149f4633b6edfffa76e897f8

data/lib/upfluence/context.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'upfluence/thread'
+
+module Upfluence
+  CONTEXT_KEY = :upfluence_context
+
+  class Context
+    attr_reader :deadline
+
+    def initialize
+      @deadline = nil
+    end
+
+    def timeout
+      return nil if @deadline.nil?
+
+      [(@deadline - Time.now).to_f, 0.0].max
+    end
+
+    def with_deadline(deadline, override: false)
+      previous = @deadline
+      @deadline = override || previous.nil? ? deadline : [previous, deadline].min
+
+      yield
+    ensure
+      @deadline = previous
+    end
+
+    def with_timeout(duration, override: false)
+      with_deadline(Time.now + duration, override: override) { yield }
+    end
+
+    class ThreadWrapper
+      class << self
+        def wrap_thread(thr, block)
+          parent_deadline = thr[CONTEXT_KEY]&.deadline
+
+          return block.call unless parent_deadline
+
+          Upfluence.context.with_deadline(parent_deadline) { block.call }
+        end
+      end
+    end
+
+    ::Upfluence::Thread.register_wrapper :context, ThreadWrapper
+  end
+
+  class << self
+    def context
+      Thread.current[CONTEXT_KEY] ||= Context.new
+    end
+  end
+end

data/lib/upfluence/endpoint/api_endpoint.rb

@@ -1,4 +1,4 @@
-require 'sinatra'
+require 'sinatra/base'
 require 'upfluence/http/endpoint/api_endpoint'
 
 module Upfluence

data/lib/upfluence/http/endpoint/api_endpoint.rb

@@ -1,4 +1,4 @@
-require 'sinatra'
+require 'sinatra/base'
 require 'active_record'
 require 'active_support/hash_with_indifferent_access'
 require 'upfluence/http/endpoint/validation_error'

data/lib/upfluence/http/middleware/request_stapler.rb

@@ -1,14 +1,20 @@
+require 'upfluence/context'
+
 module Upfluence
   module HTTP
     module Middleware
       class RequestStapler
-        def initialize(app)
+        def initialize(app, timeout: nil)
+          @timeout = timeout
           @app = app
         end
 
         def call(env)
           Server.request = Rack::Request.new(env)
-          @app.call(env)
+
+          return @app.call(env) unless @timeout
+
+          Upfluence.context.with_timeout(@timeout) { @app.call(env) }
         end
       end
     end

data/lib/upfluence/http/server.rb

@@ -3,7 +3,7 @@ require 'rack/etag'
 require 'rack/timeout/base'
 require 'prometheus/client'
 require 'prometheus/client/push'
-require "prometheus/middleware/exporter"
+require 'prometheus/middleware/exporter'
 
 require 'upfluence/environment'
 require 'upfluence/error_logger'
@@ -48,20 +48,78 @@ module Upfluence
           Instrumentation::GCInstrumenter.new,
           Instrumentation::ActiveRecordPoolInstrumenter.new
         ],
+        admin_port:            ENV.fetch('ADMIN_PORT', nil),
         debug:                 ENV.fetch('DEBUG', nil)
       }
 
       def initialize(options = {}, &block)
         @options = DEFAULT_OPTIONS.dup.merge(options)
         opts = @options
-        base_handler = nil
 
         if opts[:base_handler_klass]
-          base_handler = opts[:base_handler_klass].new(@options[:interfaces])
+          @base_handler = opts[:base_handler_klass].new(opts[:interfaces])
         end
 
-        @builder = Builder.new do
-          use Middleware::RequestStapler
+        @admin_builder = admin_builder(opts) if opts[:admin_port]
+        @production_builder = production_builder(opts, &block)
+        @handler = Rack::Handler.get(opts[:server])
+      end
+
+      def serve
+        ENV['RACK_ENV'] = Upfluence.env.to_s
+
+        Thread.new { run_prometheus_exporter } if @options[:push_gateway_url]
+
+        @options[:instrumentations].each(&:start)
+
+        if @admin_builder
+          admin_port = @options[:admin_port].to_i
+
+          Thread.new do
+            run_builder(@admin_builder, Port: admin_port)
+          end
+
+          Upfluence.logger.info(
+            "Admin server listening on #{@options[:Host]}:#{admin_port}"
+          )
+        end
+
+        run_builder(@production_builder)
+      end
+
+      class << self
+        def request
+          Thread.current[REQUEST_CONTEXT_KEY]
+        end
+
+        def request=(req)
+          Thread.current[REQUEST_CONTEXT_KEY] = req
+        end
+      end
+
+      private
+
+      def run_builder(builder, **overrides)
+        opts = @options.merge(overrides)
+
+        @handler.run(builder, **opts) do |server|
+          server.threaded = opts[:threaded] if server.respond_to? :threaded=
+
+          # Thin does not recognize the max_thread argument, howerver it has a
+          # threadpool_size setter. Puma on the other hand recognize max_thread.
+          if server.respond_to?(:threadpool_size=) && opts[:max_threads]
+            server.threadpool_size = opts[:max_threads]
+          end
+        end
+      end
+
+      def production_builder(opts, &block)
+        base_handler = @base_handler
+        has_admin = !opts[:admin_port].nil?
+        mount = method(:mount_admin_endpoints)
+
+        Builder.new do
+          use Middleware::RequestStapler, timeout: opts[:request_timeout]
           use Middleware::Logger
           use Middleware::Prometheus
           use Middleware::ApplicationHeaders, base_handler
@@ -72,7 +130,6 @@ module Upfluence
           end
 
           use Upfluence.error_logger.middleware
-          use Prometheus::Middleware::Exporter if opts[:prometheus_endpoint]
 
           use Rack::ContentLength
           use Rack::Chunked
@@ -86,54 +143,46 @@ module Upfluence
             use(*m)
           end
 
+          mount.call(self, opts) unless has_admin
+
           map '/healthcheck' do
             run(opts[:healthcheck_endpoint] || Endpoint::Healthcheck.new)
           end
 
-          if opts[:base_processor_klass] && base_handler
-            map '/base' do
-              run_thrift(opts[:base_processor_klass], base_handler)
-            end
-          end
-
-          map('/debug') { run(Endpoint::Profiler.new) } if opts[:debug]
-
           instance_eval(&block)
         end
-
-        @handler = Rack::Handler.get(@options[:server])
       end
 
-      def serve
-        ENV['RACK_ENV'] = Upfluence.env.to_s
-
-        Thread.new { run_prometheus_exporter } if @options[:push_gateway_url]
-
-        @options[:instrumentations].each(&:start)
+      def admin_builder(opts)
+        mount = method(:mount_admin_endpoints)
 
-        @handler.run(@builder, **@options) do |server|
-          server.threaded = @options[:threaded] if server.respond_to? :threaded=
+        Builder.new do
+          use Rack::ContentLength
 
-          # Thin does not recognize the max_thread argument, howerver it has a
-          # threadpool_size setter. Puma on the other hand recognize max_thread.
-          if server.respond_to?(:threadpool_size=) && @options[:max_threads]
-            server.threadpool_size = @options[:max_threads]
+          map '/healthcheck' do
+            run(opts[:healthcheck_endpoint] || Endpoint::Healthcheck.new)
           end
+
+          mount.call(self, opts)
         end
       end
 
-      class << self
-        def request
-          Thread.current[REQUEST_CONTEXT_KEY]
-        end
+      def mount_admin_endpoints(builder, opts)
+        base_handler = @base_handler
 
-        def request=(req)
-          Thread.current[REQUEST_CONTEXT_KEY] = req
+        builder.instance_eval do
+          use Prometheus::Middleware::Exporter if opts[:prometheus_endpoint]
+
+          if opts[:base_processor_klass] && base_handler
+            map '/base' do
+              run_thrift(opts[:base_processor_klass], base_handler)
+            end
+          end
+
+          map('/debug') { run(Endpoint::Profiler.new) } if opts[:debug]
         end
       end
 
-      private
-
       def run_prometheus_exporter
         push = Prometheus::Client::Push.new(
           @options[:app_name],

data/lib/upfluence/pool.rb

@@ -1,11 +1,82 @@
-require 'thread'
-require 'timeout'
+require 'upfluence/timeout'
 
 module Upfluence
   class Pool
     class UnknownResource < RuntimeError; end
     class NoInstanciationBlock < RuntimeError; end
 
+    class PrometheusMetrics
+      def self.standardized_metrics(n)
+        require 'prometheus/client'
+        new(Prometheus::Client.registry, 'upfluence_iopool_pool', { pool: n })
+      end
+
+      def initialize(registry, prefix, labels)
+        label_keys = labels.keys
+
+        @labels            = labels
+        @get               = register(registry, :counter, :"#{prefix}_get_total", 'Total pool get calls', label_keys)
+        @put               = register(registry, :counter, :"#{prefix}_put_total", 'Total pool put calls', label_keys)
+        @discard           = register(registry, :counter, :"#{prefix}_discard_total", 'Total pool discard calls',
+                                      label_keys)
+        @get_wait          = register(registry, :counter, :"#{prefix}_get_wait_total", 'Pool gets that had to wait',
+                                      label_keys)
+        @get_wait_duration = register(registry, :counter, :"#{prefix}_get_wait_millisecond_total",
+                                      'Total milliseconds waiting for pool get', label_keys)
+        @idle              = register(registry, :gauge,   :"#{prefix}_idle", 'Idle resources in pool', label_keys)
+        @checkout          = register(registry, :gauge,   :"#{prefix}_checkout", 'Checked out resources in pool',
+                                      label_keys)
+        @size              = register(registry, :gauge,   :"#{prefix}_size", 'Total pool size', label_keys)
+      end
+
+      def observe_get
+        @get.increment(labels: @labels)
+      end
+
+      def observe_put
+        @put.increment(labels: @labels)
+      end
+
+      def observe_discard
+        @discard.increment(labels: @labels)
+      end
+
+      def observe_wait(seconds)
+        @get_wait.increment(labels: @labels)
+        @get_wait_duration.increment(by: (seconds * 1000).to_i, labels: @labels)
+      end
+
+      def update_idle(count)
+        @idle.set(count, labels: @labels)
+      end
+
+      def update_checkout(count)
+        @checkout.set(count, labels: @labels)
+      end
+
+      def set_size(count)
+        @size.set(count, labels: @labels)
+      end
+
+      private
+
+      def register(registry, type, name, docstring, label_keys)
+        registry.public_send(type, name, docstring: docstring, labels: label_keys)
+      rescue Prometheus::Client::Registry::AlreadyRegisteredError
+        registry.get(name)
+      end
+    end
+
+    class NullMetrics
+      def observe_get; end
+      def observe_put; end
+      def observe_discard; end
+      def observe_wait(_seconds); end
+      def update_idle(_count); end
+      def update_checkout(_count); end
+      def set_size(_count); end
+    end
+
     attr_reader :max
 
     def initialize(size = 0, options = {}, &block)
@@ -19,37 +90,63 @@ module Upfluence
       @resource = ConditionVariable.new
       @shutdown_block = nil
       @timeout = options.fetch :timeout, 5
+      @metrics = options.fetch(:metrics, NullMetrics.new)
+
+      @metrics.set_size(size)
     end
 
     def discard(obj)
+      @metrics.observe_discard
+
       @mutex.synchronize do
         remove_from_redeemed obj
+        @metrics.update_checkout(@redeemed.length)
         @resource.broadcast
       end
     end
 
     def push(obj)
+      @metrics.observe_put
+
       @mutex.synchronize do
         remove_from_redeemed obj
 
         @que.push obj
+        @metrics.update_idle(@que.length)
+        @metrics.update_checkout(@redeemed.length)
         @resource.broadcast
       end
     end
 
     def pop(options = {})
       timeout = options.fetch :timeout, @timeout
-      deadline = Time.now + timeout
+      effective = [timeout, Upfluence.context.timeout].compact.min
+      deadline = Time.now + effective
+      t0 = nil
+
+      @metrics.observe_get
 
       @mutex.synchronize do
         loop do
-          return redeem(@que.pop) unless @que.empty?
+          unless @que.empty?
+            result = redeem(@que.pop)
+            @metrics.update_idle(@que.length)
+            @metrics.observe_wait(Time.now - t0) if t0
+            return result
+          end
 
-          connection = redeem(try_create(options))
-          return connection if connection
+          connection = try_create(options)
+
+          if connection
+            result = redeem(connection)
+            @metrics.observe_wait(Time.now - t0) if t0
+            return result
+          end
 
           to_wait = deadline - Time.now
-          raise Timeout::Error, "Waited #{timeout} sec" if to_wait <= 0
+          raise ::Timeout::Error.new("Waited #{timeout} sec") if to_wait <= 0
+
+          t0 ||= Time.now
           @resource.wait(@mutex, to_wait)
         end
       end
@@ -66,15 +163,14 @@ module Upfluence
     private
 
     def remove_from_redeemed(obj)
-      unless @redeemed.map(&:object_id).include? obj.object_id
-        raise UnknownResource
-      end
+      raise UnknownResource unless @redeemed.map(&:object_id).include? obj.object_id
 
-      @redeemed.reject! { |e| e.object_id == obj.object_id }
+      @redeemed.reject! { |e| e.equal?(obj) }
     end
 
     def redeem(obj)
       @redeemed << obj if obj
+      @metrics.update_checkout(@redeemed.length)
       obj
     end
 

data/lib/upfluence/timeout.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'timeout'
+require 'upfluence/context'
+
+module Upfluence
+  module Timeout
+    def self.timeout(sec, klass = nil, message = nil, &block)
+      effective = [sec, Upfluence.context.timeout].compact.min
+
+      raise(klass || ::Timeout::Error, message) if effective <= 0
+
+      Upfluence.context.with_timeout(effective) do
+        ::Timeout.timeout(effective, klass, message, &block)
+      end
+    end
+  end
+end

data/lib/upfluence/utils/thrift/middleware/timeout.rb

@@ -1,3 +1,5 @@
+require 'upfluence/timeout'
+
 module Upfluence
   module Utils
     module Thrift
@@ -9,7 +11,7 @@ module Upfluence
           end
 
           def method_missing(method, *args, &block)
-            ::Timeout.timeout(@duration) { @app.send(method, *args, &block) }
+            Upfluence::Timeout.timeout(@duration) { @app.send(method, *args, &block) }
           rescue ::Timeout::Error
             raise ::Thrift::ApplicationException.new(
               ::Thrift::ApplicationException::INTERNAL_ERROR,

data/lib/upfluence/utils/version.rb

@@ -1,5 +1,5 @@
 module Upfluence
   module Utils
-    VERSION = '0.12.20'.freeze
+    VERSION = '0.13.0'.freeze
   end
 end

data/lib/upfluence.rb

@@ -1,3 +1,4 @@
+require 'upfluence/context'
 require 'upfluence/utils'
 require 'upfluence/endpoint/api_endpoint'
 require 'upfluence/mixin/strong_parameters'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: upfluence-utils
 version: !ruby/object:Gem::Version
-  version: 0.12.20
+  version: 0.13.0
 platform: ruby
 authors:
 - Upfluence
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-06-26 00:00:00.000000000 Z
+date: 2026-07-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -280,6 +280,7 @@ files:
 - lib/test.rb
 - lib/upfluence.rb
 - lib/upfluence/amqp/server.rb
+- lib/upfluence/context.rb
 - lib/upfluence/endpoint/api_endpoint.rb
 - lib/upfluence/environment.rb
 - lib/upfluence/error_logger.rb
@@ -311,6 +312,7 @@ files:
 - lib/upfluence/resources.rb
 - lib/upfluence/resources/countries.rb
 - lib/upfluence/thread.rb
+- lib/upfluence/timeout.rb
 - lib/upfluence/utils.rb
 - lib/upfluence/utils/env_helper.rb
 - lib/upfluence/utils/http/middleware/null.rb