async-tools 0.1.10 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7e998dd042f7fc4c496862c3ca2feec5f370ac86c803dcc61c55d970f6bae28a
-  data.tar.gz: fcd146663d144d9ccf9738c58594faabda6b98cf754523b1145b65016715eac7
+  metadata.gz: 8b3b08f9b120bebf744df3e7c0da6e2cb7c8d4c5acb01458c25f8be8ff7588fa
+  data.tar.gz: 7c02d0bfce7a3bcb21b8ac8b2f4a8aec4bfad5a12233141b7d1d73b139c08684
 SHA512:
-  metadata.gz: 6315fe469b3e53cdfb87cd569e4833eb34669ab961d3a16fd1c435b5490dd52087ebfe55b8fea41ea997759918d695ab1f999effecd43cf73419cbd5a60d3a47
-  data.tar.gz: 720846506b9f600528c7c1ada372741abd42bd2588ab2c4f9e0ec53ea7e19877b08b9bac37b103345092e9fcf67a493c2714149c06e5211f7257c609657385f2
+  metadata.gz: 496680113c44a54745da6846bca478f426454eaa34c125de569205c9f5fe3bc82ec6fe53589f8c86c0b1222361ec949c7938baa64b2be0246a15da280ca8f30a
+  data.tar.gz: 14d6d23403ede1040d74e68590ad0572e1c01b402ff6d7d0ff25dfb11c6f0f7a187b894c5681772e7828c88a8ba5f2e95751a3bce58ba9d9dc2aa14c31078e67

data/.github/workflows/main.yml

@@ -1,6 +1,8 @@
 name: Ruby
 
-on: [push]
+on:
+  - push
+  - workflow_dispatch
 
 jobs:
   lint:

data/.rubocop.yml

@@ -51,3 +51,12 @@ Metrics/MethodLength:
 
 Lint/UnusedBlockArgument:
   Enabled: false
+
+Style/SymbolArray:
+  EnforcedStyle: brackets
+
+Style/WordArray:
+  EnforcedStyle: brackets
+
+Style/NumberedParametersLimit:
+  Max: 2

data/Gemfile.lock

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

data/Rakefile

@@ -9,4 +9,4 @@ require "rubocop/rake_task"
 
 RuboCop::RakeTask.new
 
-task default: %i[spec rubocop]
+task default: [:spec, :rubocop]

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+class Async::App
+  extend Async::App::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
+    @task = Async::Task.current
+
+    set_traps!
+    {
+      bus: Async::Bus.new(app_name),
+      **container_config
+    }.each { container.register(_1, _2) }
+
+    start_metrics_server!
+    run!
+    info { "Started" }
+  rescue StandardError => e
+    fatal { e }
+    stop
+    exit(1)
+  end
+  # rubocop:enable Style/GlobalVars
+
+  def container = @container ||= Dry::Container.new
+  def run! = nil
+  def container_config = {}
+  def app_name = :async_app
+
+  def stop
+    @task&.stop
+    info { "Stopped" }
+  end
+
+  private
+
+  def set_traps!
+    trap("INT") do
+      force_exit! if @stopping
+      @stopping = true
+      warn { "Interrupted, stopping. Press ^C once more to force exit." }
+      stop
+    end
+
+    trap("TERM") { stop }
+  end
+
+  def force_exit!
+    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/bus.rb

@@ -1,12 +1,47 @@
 # frozen_string_literal: true
 
-# Threading is not supported!
-module Async::Bus
-  class << self
-    def get(name = :default)
-      @buses ||= {}
-      @buses[name] ||= Bus.new(name:)
-      @buses[name]
+class Async::Bus
+  include Async::Logger
+  # dry-events is not a dependency of async-tools on purpose.
+  # add it to your bundle yourself
+
+  # Semantics:
+  # - Lazily registeres events
+  # - Synchronous by default
+  # - Catches exceptions in subscribers, logs them
+  def initialize(name)
+    @name = name
+    @w = Class.new.include(Dry::Events::Publisher[name]).new
+  end
+
+  # BLOCKING unless subscribers run in tasks
+  def publish(name, *args, **params)
+    @w.register_event(name)
+    @w.publish(name, payload: (args.first || params))
+  rescue StandardError => e
+    log_error(name, e)
+  end
+
+  # NON-BLOCKING
+  def subscribe(name)
+    @w.register_event(name)
+    @w.subscribe(name) { yield(_1[:payload]) }
+  end
+
+  # NON-BLOCKING, runs subscriber in a task
+  def async_subscribe(name, parent: Async::Task.current)
+    subscribe(name) do |event|
+      parent.async  do
+        yield(event)
+      rescue StandardError => e
+        log_error(name, e)
+      end
     end
   end
+
+  def convert(from_event, to_event) = subscribe(from_event) { publish(to_event, **yield(_1)) }
+
+  private
+
+  def log_error(name, e) = warn("Subscriber for #{name.inspect} failed with exception.", e)
 end

data/lib/async/logger.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Async::Logger
+  [:debug, :info, :warn, :error, :fatal].each do |name|
+    define_method(name) do |*args, &block|
+      info = respond_to?(:logger_info, true) ? logger_info : nil
+
+      Console.logger.public_send(name, self, info, *args, &block)
+    end
+  end
+end

data/lib/async/tools/version.rb

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

data/lib/async/tools.rb

@@ -12,6 +12,7 @@ loader = Zeitwerk::Loader.new
 loader.tag = File.basename(__FILE__, ".rb")
 loader.inflector = Zeitwerk::GemInflector.new(__FILE__)
 loader.push_dir(File.expand_path("..", __dir__.to_s))
+
 loader.setup
 
 module Async

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: async-tools
 version: !ruby/object:Gem::Version
-  version: 0.1.10
+  version: 0.2.2
 platform: ruby
 authors:
 - Gleb Sinyavskiy
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-03-02 00:00:00.000000000 Z
+date: 2023-03-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async
@@ -60,9 +60,16 @@ files:
 - async-tools.gemspec
 - 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/bus/bus.rb
 - lib/async/channel.rb
+- lib/async/logger.rb
 - lib/async/q.rb
 - lib/async/result_notification.rb
 - lib/async/timer.rb

data/lib/async/bus/bus.rb

@@ -1,95 +0,0 @@
-# frozen_string_literal: true
-
-class Async::Bus::Bus
-  attr_reader :name
-
-  include Console
-
-  def initialize(name: :default, limit: 10, parent: Async::Task.current)
-    @name = name
-    @limit = limit
-    @parent = parent
-
-    @closed = false
-
-    @subscribers = Hash.new { |hash, key| hash[key] = [] }
-  end
-
-  # Blocks if any of output channels is full!
-  def publish(nameable_or_event, **payload)
-    check_if_open!
-    name, payload = normalize(nameable_or_event, payload)
-
-    subs = @subscribers[name]
-    return if subs.empty?
-
-    subs.each do |chan|
-      publishing_blocked if chan.full?
-      chan << [name, payload]
-    end
-    Async::Task.current.yield
-  end
-
-  # Blocks!
-  def subscribe(nameable, callable = nil, &block)
-    check_if_open!
-    callable ||= block
-    unless callable.respond_to?(:call)
-      raise ArgumentError, "callable or block must be provided. callable must respond to :call"
-    end
-
-    event_name = normalize(nameable).first
-
-    chan = Async::Channel.new(@limit)
-    @subscribers[event_name] << chan
-    serve(chan, event_name, callable)
-  end
-
-  def async_subscribe(*, **, &) = @parent.async { subscribe(*, **, &) }
-  def on_event(&block) = @on_event_callback = block
-
-  def close
-    return if @closed
-
-    @closed = true
-
-    @subscribers.values.flatten.each(&:close)
-    @subscribers.clear
-  end
-
-  private
-
-  def normalize(nameable, payload = nil)
-    return [nameable, payload] if nameable.is_a?(Symbol)
-    return [nameable.to_sym, payload] if nameable.is_a?(String)
-    return [nameable.event_name.to_sym, nameable] if nameable.respond_to?(:event_name)
-
-    n = nameable[:event_name] || nameable["event_name"]
-    return [n.to_sym, nameable] if n
-
-    raise ArgumentError, "cannot infer event name from #{nameable.inspect}"
-  end
-
-  def serve(chan, event_name, callable)
-    stopped = false
-    unsub = lambda {
-      chan.close
-      stopped = true
-      @subscribers[event_name].delete(chan)
-    }
-
-    chan.each do |name, payload|
-      @on_event_callback&.call(wrapper)
-      callable.call(payload, unsub:, meta: { bus: self })
-      break if stopped
-    end
-  end
-
-  def publishing_blocked
-    logger.warn(self) { "One of the subscribers is slow, blocking publishing. Event name: #{name}" }
-  end
-
-  def check_if_open!
-    raise "Bus is closed" if @closed
-  end
-end