async-tools 0.2.1 → 0.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 37e9af668ebad3f0c2356cc2a428b1bedf8b432e239099dd1b961f16d0b01036
-  data.tar.gz: 201bc5e60a2b19e5a1b1498c14c0e792e96bd21a688b3605f443e6f98a2b6f29
+  metadata.gz: ec1be570dca6a72219f3a39a96a7df91da1783ac2eeff110797f924a3fea3f5e
+  data.tar.gz: f16ce65bc17d3652f6e89eb44a95c9f07ba9fd6852328d317d0a023bdaff5138
 SHA512:
-  metadata.gz: f92056eef4bc4dc65210c682b8637fc6e39088b1213cca0f4b9bf54a06a5b736ce841c351bbaf211bac3777ccda8a7220ee2a926d822e54758a83e87b5c856f8
-  data.tar.gz: e463ee25e793a281c1130ede835c427f03c47f15bd51d708f28396533652ef6be14e7ecd0b08b577ec2dadf73e8ec90522bc986a6911b64ea1f049c3c5cd264e
+  metadata.gz: 13f5d055571394818ed8f3e9e06abd39bcb778a060b489fff53331f572a512089767967b0ba16697a8b024c242cfe55c709ccf5be954e4425e33d58cc7b5c512
+  data.tar.gz: 1f79f53e28dccd8355416e9f51ee25cd65df6d8253375853122173caef6cc5173cb5923fab212399fd71d160276c2898ffeae79e32df94ae48cf43465b5f2d36

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    async-tools (0.2.1)
+    async-tools (0.2.4)
       async (~> 2.3)
       zeitwerk (~> 2.6)
 

data/lib/async/app/component.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Async::App::Component
+  def self.included(base)
+    base.extend(Async::App::Injector)
+    base.inject(:bus)
+
+    base.include(Async::Logger)
+
+    strict = Dry.Types::Strict
+
+    string_like = (strict::String | strict::Symbol).constructor(&:to_s)
+    kv = strict::Hash.map(string_like, strict::String)
+
+    base.const_set(:T, Module.new do
+      include Dry.Types
+      const_set(:StringLike, string_like)
+      const_set(:KV, kv)
+    end)
+  end
+end

data/lib/async/app/injector.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Async::App::Injector
+  def inject(name)
+    define_method(name) do
+      $__ASYNC_APP.container[name] # rubocop:disable Style/GlobalVars
+    end
+    private name
+  end
+end

data/lib/async/app/metrics/ruby_runtime_monitor.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+class Async::App::Metrics::RubyRuntimeMonitor
+  include Async::Logger
+
+  INTERVAL = 2
+
+  def run
+    Async::Timer.new(INTERVAL, run_on_start: true, on_error: ->(e) { warn(e) }) do
+      fibers = ObjectSpace.each_object(Fiber)
+      threads = ObjectSpace.each_object(Thread)
+      ractors = ObjectSpace.each_object(Ractor)
+
+      yield({
+        ruby_fibers: { value: fibers.count },
+        ruby_fibers_active: { value: fibers.count(&:alive?) },
+        ruby_threads: { value: threads.count },
+        ruby_threads_active: { value: threads.count(&:alive?) },
+        ruby_ractors: { value: ractors.count },
+        ruby_memory: { value: GetProcessMem.new.bytes.to_s("F"), suffix: "bytes" }
+      })
+    end
+    info { "Started" }
+  end
+end

data/lib/async/app/metrics/serializer.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+class Async::App::Metrics::Serializer
+  def initialize(prefix:)
+    @prefix = prefix
+  end
+
+  def serialize(metrics)
+    metrics.flat_map { metric_line(_1) }
+           .compact
+           .join("\n")
+           .then { "#{_1}\n" }
+  end
+
+  def metric_name(value) = "#{@prefix}_#{value[:name]}_#{value[:suffix]}"
+
+  def metric_labels(value) = value[:labels].map { |tag, tag_value| "#{tag}=#{tag_value.to_s.inspect}" }.join(",")
+
+  def metric_line(value)
+    labels = metric_labels(value)
+
+    "#{metric_name(value)}{#{labels}} #{value[:value]}" if value.key?(:value)
+  end
+end

data/lib/async/app/metrics/server.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+class Async::App::Metrics::Server
+  include Async::Logger
+
+  PATHS = ["/metrics", "/metrics/"].freeze
+
+  def initialize(prefix:, port: 8080)
+    @prefix = prefix
+    @port = port
+  end
+
+  def run
+    Async::App::Metrics::RubyRuntimeMonitor.new.run { update_metrics(_1) }
+
+    endpoint = Async::HTTP::Endpoint.parse("http://0.0.0.0:#{@port}")
+    Async { Async::HTTP::Server.new(self, endpoint).run }
+    info { "Started on #{endpoint.url}" }
+  end
+
+  def call(request)
+    return Protocol::HTTP::Response[404, {}, ["Not found"]] unless PATHS.include?(request.path)
+
+    Protocol::HTTP::Response[200, {}, serializer.serialize(metrics_store)]
+  end
+
+  def update_metrics(metrics) = metrics.each { metrics_store.set(_1, **_2) }
+
+  private
+
+  def metrics_store = @metrics_store ||= Async::App::Metrics::Store.new
+  def serializer = @serializer ||= Async::App::Metrics::Serializer.new(prefix: @prefix)
+end

data/lib/async/app/metrics/store.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+class Async::App::Metrics::Store
+  include Enumerable
+
+  def set(name, value:, suffix: "total", **labels)
+    key = [name, labels]
+    counters[key] ||= { name:, labels:, suffix:, value: }
+    counters[key].merge!(value:)
+  end
+
+  def each(&) = counters.values.each(&)
+
+  private
+
+  def counters = @counters ||= {}
+end

data/lib/async/app.rb

@@ -1,52 +1,26 @@
 # frozen_string_literal: true
 
 class Async::App
-  # rubocop:disable Style/GlobalVars
-
-  module Injector
-    def inject(name)
-      define_method(name) do
-        $__ASYNC_APP.container[name]
-      end
-      private name
-    end
-  end
-
-  module Component
-    def self.included(base)
-      base.extend(Injector)
-      base.inject(:bus)
+  extend Async::App::Injector
 
-      base.include(Async::Logger)
-
-      strict = Dry.Types::Strict
-
-      string_like = (strict::String | strict::Symbol).constructor(&:to_s)
-      kv = strict::Hash.map(string_like, strict::String)
-
-      base.const_set(:T, Module.new do
-        include Dry.Types
-        const_set(:StringLike, string_like)
-        const_set(:KV, kv)
-      end)
-    end
-  end
-
-  extend Injector
   include Async::Logger
 
   inject :bus
 
+  # rubocop:disable Style/GlobalVars
   def initialize
     raise "only one instance of #{self.class} is allowed" if $__ASYNC_APP
 
     $__ASYNC_APP = self
-
-    container.register(:bus, Async::Bus.new(:__async_app))
+    @task = Async::Task.current
 
     set_traps!
-    @task = Async::Task.current
-    container_config.each { container.register(_1, _2) }
+    {
+      bus: Async::Bus.new(app_name),
+      **container_config
+    }.each { container.register(_1, _2) }
+
+    start_metrics_server!
     run!
     info { "Started" }
   rescue StandardError => e
@@ -59,6 +33,7 @@ class Async::App
   def container = @container ||= Dry::Container.new
   def run! = nil
   def container_config = {}
+  def app_name = :async_app
 
   def stop
     @task&.stop
@@ -82,4 +57,10 @@ class Async::App
     fatal { "Forced exit" }
     exit(1)
   end
+
+  def start_metrics_server!
+    Metrics::Server.new(prefix: app_name).tap(&:run).tap do |server|
+      bus.subscribe("metrics.updated") { server.update_metrics(_1) }
+    end
+  end
 end

data/lib/async/cache.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+class Async::Cache
+  Item = Struct.new("Item", :task, :value, :created_at, :duration) do
+    def expired? = created_at && Time.now - created_at >= duration
+  end
+
+  def cache(id, duration:, parent: Async::Task.current)
+    cleanup!
+    find_or_create(id, duration:) do |item|
+      parent.async do |task|
+        item.task = task
+        item.value = yield(id) if block_given?
+        item.created_at = Time.now
+      end.wait
+    end.value
+  end
+
+  def cleanup! = storage.delete_if { _2.expired? }
+  def count = storage.count
+
+  private
+
+  def find_or_create(id, duration:)
+    storage[id].tap do |item|
+      item.duration = duration
+      item.task&.wait
+      return item if item.created_at
+
+      yield(item)
+    end
+  end
+
+  def storage = @storage ||= Hash.new { _1[_2] = Item.new }
+end

data/lib/async/throttler.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+# inspired by https://github.com/negativecode/vines/blob/master/lib/vines/token_bucket.rb
+class Async::Throttler
+  def initialize(capacity, rate, parent: Async::Task.current)
+    raise ArgumentError, "capacity must be > 0" unless capacity.positive?
+    raise ArgumentError, "rate must be > 0" unless rate.positive?
+
+    @capacity = capacity
+    @tokens = capacity
+    @rate = rate
+    @parent = parent
+
+    @timestamp = Time.new
+  end
+
+  def wait(timeout: 0)
+    with_timeout(timeout) do
+      while @tokens < 1
+        fill!
+        sleep(1.0 / @rate)
+      end
+    end
+
+    @tokens -= 1
+  end
+
+  def async(parent: @parent, timeout: 0, &)
+    wait(timeout:)
+    parent.async(&)
+  end
+
+  private
+
+  def with_timeout(timeout, &)
+    return yield if timeout.zero?
+
+    Fiber.scheduler.with_timeout(timeout, &)
+  end
+
+  def fill!
+    return if @tokens >= @capacity
+
+    now = Time.new
+    @tokens += @rate * (now - @timestamp)
+    @tokens = @capacity if @tokens > @capacity
+    @timestamp = now
+  end
+end

data/lib/async/tools/version.rb

@@ -2,6 +2,6 @@
 
 module Async # rubocop:disable Style/ClassAndModuleChildren
   module Tools
-    VERSION = "0.2.1"
+    VERSION = "0.2.4"
   end
 end

data/lib/async/tools.rb

@@ -22,9 +22,11 @@ module Async
     end
   end
 
-  def self.map(collection, **params, &)
-    WorkerPool.with(queue_limit: collection.count, **params) do |pool|
-      pool.schedule_all(collection, &).map(&:wait)
+  def self.map(collection, concurrency: nil, parent: Async::Task.current, &)
+    Async::Semaphore.new(concurrency || collection.count, parent:).then do |s|
+      collection.map do |item|
+        s.async { yield(item) }
+      end.map(&:wait)
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: async-tools
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.4
 platform: ruby
 authors:
 - Gleb Sinyavskiy
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-03-03 00:00:00.000000000 Z
+date: 2023-03-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async
@@ -61,11 +61,19 @@ files:
 - bin/console
 - bin/setup
 - lib/async/app.rb
+- lib/async/app/component.rb
+- lib/async/app/injector.rb
+- lib/async/app/metrics/ruby_runtime_monitor.rb
+- lib/async/app/metrics/serializer.rb
+- lib/async/app/metrics/server.rb
+- lib/async/app/metrics/store.rb
 - lib/async/bus.rb
+- lib/async/cache.rb
 - lib/async/channel.rb
 - lib/async/logger.rb
 - lib/async/q.rb
 - lib/async/result_notification.rb
+- lib/async/throttler.rb
 - lib/async/timer.rb
 - lib/async/tools.rb
 - lib/async/tools/version.rb